/*
 *
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

package org.apache.royale.compiler.internal.targets;

import java.io.File;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;

import org.apache.royale.abc.ABCConstants;
import org.apache.royale.abc.ABCEmitter;
import org.apache.royale.abc.instructionlist.InstructionList;
import org.apache.royale.abc.semantics.Name;
import org.apache.royale.compiler.constants.IASLanguageConstants;
import org.apache.royale.compiler.definitions.IClassDefinition;
import org.apache.royale.compiler.definitions.IDefinition;
import org.apache.royale.compiler.definitions.references.IResolvedQualifiersReference;
import org.apache.royale.compiler.definitions.references.ReferenceFactory;
import org.apache.royale.compiler.internal.abc.ClassGeneratorHelper;
import org.apache.royale.compiler.internal.definitions.ClassDefinition;
import org.apache.royale.compiler.internal.projects.RoyaleProject;
import org.apache.royale.compiler.problems.ICompilerProblem;
import org.apache.royale.compiler.problems.ResourceBundleNotFoundForLocaleProblem;
import org.apache.royale.compiler.problems.ResourceBundleNotFoundProblem;
import org.apache.royale.compiler.targets.ITargetSettings;
import org.apache.royale.compiler.units.ICompilationUnit;
import org.apache.royale.swf.ISWF;
import org.apache.royale.swf.SWFFrame;
import org.apache.royale.swf.tags.DoABCTag;
import com.google.common.collect.ForwardingCollection;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Sets;

public final class RoyaleLibrarySWFTarget extends LibrarySWFTarget
{
    public RoyaleLibrarySWFTarget(RoyaleProject project, ITargetSettings targetSettings, Set<ICompilationUnit> rootedCompilationUnits)
    {
        super(project, targetSettings, rootedCompilationUnits);
        royaleProject = project;
        delegate = new FlexDelegate(targetSettings, project);
        isLibrary = true;
    }
    
    private final RoyaleProject royaleProject;
    
    private ModuleFactoryInfo moduleFactoryInfo;
    
    private final FlexDelegate delegate;
    
    private ModuleFactoryInfo computeModuleFactoryInfo()
    {
        final IResolvedQualifiersReference moduleFactoryBaseClassReference =
            ReferenceFactory.packageQualifiedReference(royaleProject.getWorkspace(), getBaseClassQName());
        final IDefinition moduleFactoryBaseClassDef =
            moduleFactoryBaseClassReference.resolve(royaleProject);
        if (!(moduleFactoryBaseClassDef instanceof ClassDefinition))
            return ModuleFactoryInfo.create(Collections.<ICompilerProblem>emptyList()); // TODO make a compiler problem here!
        
        final ClassDefinition moduleFactoryBaseClass =
            (ClassDefinition)moduleFactoryBaseClassDef;
        
        final ICompilationUnit moduleFactoryBaseClassCompilationUnit =
            royaleProject.getScope().getCompilationUnitForDefinition(moduleFactoryBaseClass);
        assert moduleFactoryBaseClassCompilationUnit != null : "Unable to find compilation unit for definition!";
        
        return ModuleFactoryInfo.create(getGeneratedModuleFactoryClassName(moduleFactoryBaseClass), moduleFactoryBaseClass, moduleFactoryBaseClassCompilationUnit);
    }
    
    private ModuleFactoryInfo getModuleFactoryInfo()
    {
        if (moduleFactoryInfo != null)
            return moduleFactoryInfo;
        moduleFactoryInfo = computeModuleFactoryInfo();
        return moduleFactoryInfo;
    }
    
    @Override
    public String getBaseClassQName()
    {
        // TODO: check configuration for a user defined class.
        // Defaults to an "empty" module factory to handle the case where fonts
        // are embedded in an RSL.
        return "EmptyModuleFactory";
    }
    
    @Override
    protected FramesInformation computeFramesInformation() throws InterruptedException
    {
        final ModuleFactoryInfo moduleFactoryInfo = getModuleFactoryInfo();
        if (!moduleFactoryInfo.generateModuleFactory())
            return super.computeFramesInformation();
        final Set<ICompilationUnit> compilationUnits =
            Sets.union(Collections.singleton(moduleFactoryInfo.moduleFactoryBaseClassCompilationUnit), this.rootedCompilationUnits);
        final SWFFrameInfo frameInfo =
            new SWFFrameInfo(null, SWFFrameInfo.EXTERNS_ALLOWED, compilationUnits, moduleFactoryInfo.problems);
        final RoyaleLibrarySWFFramesInformation framesInfo = new RoyaleLibrarySWFFramesInformation(frameInfo);
        return framesInfo;
    }

    /**
     * Generated a unique name for the root class name.
     * @param baseClass
     * @return unique class name for the library.swf in this SWC.
     */
    private String getGeneratedModuleFactoryClassName(IClassDefinition moduleFactoryBaseClass)
    {
        File outputFile = targetSettings.getOutput();
        String outputName = null;
        String absolutePath = null;
        if (outputFile != null)
        {
            absolutePath = outputFile.getAbsolutePath();
            String name = outputFile.getName();
            if (name != null)
            {
                int endIndex = name.lastIndexOf('.');
                if (endIndex != -1)
                {
                    name = name.substring(0, endIndex);
                }
            }
            
            // help make root class unique by using a hashcode
            // of the absolute path of the swc.
            outputName = name + "_" + absolutePath.hashCode();
        }
        
        assert outputName != null : "Provide an output name for the SWC by setting -output";
        
        // Use system time as a fall back for a unique name for the SWC.
        if (outputName == null)
            outputName = Long.toHexString(System.nanoTime());
        
        String generatedRootName = "_" + outputName + "_" + moduleFactoryBaseClass.getQualifiedName();
        generatedRootName = generatedRootName.replaceAll("[^a-zA-Z0-9]", "_");
        return generatedRootName;
    }
    
    @Override
    protected DirectDependencies getDirectDependencies(ICompilationUnit cu) throws InterruptedException
    {
        final DirectDependencies directDependencies =
            super.getDirectDependencies(cu);
        if (!targetSettings.isAccessible())
            return directDependencies;
        final DirectDependencies acccessibilityDependencies = 
            delegate.getAccessibilityDependencies(cu);
        return DirectDependencies.concat(directDependencies, acccessibilityDependencies);
    }
    
    @Override
    protected void waitForCompilationUnitToFinish(final ICompilationUnit cu, final Collection<ICompilerProblem> problems) throws InterruptedException
    {
        Collection<ICompilerProblem> problemsWithFilter = problems;
        
        // We we are externally linking a SWC into another SWC,
        // we need to filter out resource bundle not found problems
        // like the Flex 4.6.X compiler did.
        //
        // In an ideal world we would not need to do this
        // or we'd know we need to do it forever.  If we don't
        // need this filtering in the future, we can rip out this code.
        // If we continue to need this filter we should defer creation
        // of these problems until link time.
        if (getLinkageChecker().isExternal(cu))
        {
            // Collection implementation that drops
            // ICompilerProblems on the floor if they are instances of
            // ResourceBundleNotFoundProblem or
            // ResourceBundleNotFoundForLocaleProblem.
            problemsWithFilter = new ForwardingCollection<ICompilerProblem>()
            {
                @Override
                protected final Collection<ICompilerProblem> delegate()
                {
                    return problems;
                }

                @Override
                public final boolean add(ICompilerProblem element)
                {
                    if (element instanceof ResourceBundleNotFoundProblem)
                        return false;
                    if (element instanceof ResourceBundleNotFoundForLocaleProblem)
                        return false;
                    return super.add(element);
                }

                @Override
                public final boolean addAll(Collection<? extends ICompilerProblem> collection)
                {
                    boolean result = false;
                    for (ICompilerProblem problem : collection)
                    {
                       if (add(problem))
                           result = true;
                    }
                    return result;
                }
            };
        }
        super.waitForCompilationUnitToFinish(cu, problemsWithFilter);
    }
    
    @Override
    protected ISWF initializeSWF(List<ICompilationUnit> reachableCompilationUnits) throws InterruptedException
    {
        ISWF swf = super.initializeSWF(reachableCompilationUnits);
        delegate.addProductInfoToSWF(swf);
        
        return swf;
    }
    
    /**
     * Sub-class of {@link FramesInformation} that can create {@link SWFFrame}s
     * for all the frames in a library.swf in a royale SWC.
     * <p>
     * This class should only be constructed if we are also generating a module
     * factory.
     */
    private class RoyaleLibrarySWFFramesInformation extends FramesInformation
    {
        /**
         * Constructor
         * 
         * @param frameInfo The single {@link SWFFrameInfo} for the one frame in
         * a libary.swf in a royale SWC.
         */
        RoyaleLibrarySWFFramesInformation(SWFFrameInfo frameInfo)
        {
            super(Collections.singletonList(frameInfo));
        }

        @Override
        protected void createFrames(SWFTarget swfTarget, ISWF swf, ImmutableSet<ICompilationUnit> builtCompilationUnits, Set<ICompilationUnit> emittedCompilationUnits, Collection<ICompilerProblem> problems) throws InterruptedException
        {
            assert Iterables.size(frameInfos) == 1;
            SWFFrameInfo frameInfo = Iterables.getOnlyElement(frameInfos);
            
            final SWFFrame frame =
                createFrame(swfTarget, frameInfo, builtCompilationUnits, emittedCompilationUnits, problems);
            
            ModuleFactoryInfo moduleFactoryInfo = getModuleFactoryInfo();
            
            delegate.addGeneratedRootClassToSWFFrame(frame,
                    swf, moduleFactoryInfo, builtCompilationUnits, problems);
            swf.addFrame(frame);
            swf.setTopLevelClass(moduleFactoryInfo.generatedModuleFactoryClassName);
        }
    }

    /**
     * Helper class that keeps track of information about generating a module factory.
     * <p>
     * Module factories are generatign for library.swf's that can be used as RSLs.
     */
    private static class ModuleFactoryInfo
    {
        /**
         * Creates a {@link ModuleFactoryInfo} that will <em>not</em> cause a
         * module factory to be generated. The resulting library.swf will
         * <em>not</em> be suitable for loading as an RSL in a flex
         * application.
         * 
         * @param problems
         * @return A new {@link ModuleFactoryInfo}
         */
        static ModuleFactoryInfo create(Iterable<ICompilerProblem> problems)
        {
            return new ModuleFactoryInfo(null, null, null, problems);
        }
        
        /**
         * Creates a {@link ModuleFactoryInfo} that will cause a module factory
         * to be generated. The resulting library.swf will be suitable for
         * loading as an RSL in a royale application.
         * 
         * @param generatedModuleFactoryClassName The name of the module factory
         * to generate
         * @param moduleFactoryBaseClass The {@link ClassDefinition} for the
         * base class of the generated module factory.
         * @param moduleFactoryBaseClassCompilationUnit The
         * {@link ICompilationUnit} that defines the base class of the generated
         * module factory.
         * @return A new {@link ModuleFactoryInfo}
         */
        static ModuleFactoryInfo create(String generatedModuleFactoryClassName, IClassDefinition moduleFactoryBaseClass, ICompilationUnit moduleFactoryBaseClassCompilationUnit)
        {
            assert generatedModuleFactoryClassName != null;
            assert moduleFactoryBaseClass != null;
            assert moduleFactoryBaseClassCompilationUnit != null;
            return new ModuleFactoryInfo(generatedModuleFactoryClassName, moduleFactoryBaseClass, moduleFactoryBaseClassCompilationUnit, Collections.<ICompilerProblem>emptyList());
        }
        
        private ModuleFactoryInfo(String generatedModuleFactoryClassName, IClassDefinition moduleFactoryBaseClass, ICompilationUnit moduleFactoryBaseClassCompilationUnit, Iterable<ICompilerProblem> problems)
        {
            this.moduleFactoryBaseClass = moduleFactoryBaseClass;
            this.moduleFactoryBaseClassCompilationUnit = moduleFactoryBaseClassCompilationUnit;
            this.problems = problems;
            this.generatedModuleFactoryClassName = generatedModuleFactoryClassName;
        }
        
        /**
         * Determins if a module factory should be generated.
         * 
         * @return true if a module factory should be generated, false
         * otherwise.
         */
        boolean generateModuleFactory()
        {
            return moduleFactoryBaseClass != null;
        }
        
        final IClassDefinition moduleFactoryBaseClass;
        final ICompilationUnit moduleFactoryBaseClassCompilationUnit;
        final Iterable<ICompilerProblem> problems;
        final String generatedModuleFactoryClassName;
    }


    /**
     * Sub-class of {@link RoyaleTarget} that adds logic specific to building 
     * library.swf's in royale SWCs.
     */
    private class FlexDelegate extends RoyaleTarget
    {

        FlexDelegate(ITargetSettings targetSettings, RoyaleProject project)
        {
            super(targetSettings, project);
        }
        
        /**
         * Add the generated root class and its dependencies to the specified frame.
         * 
         * @param frame
         * @param swf
         * @param baseClass
         * @param projectScope
         * @param allowExternals if true, allow symbols to be externalized in this frame.
         * @param emittedCompilationUnits
         * @param problemCollection
         * @return
         * @throws InterruptedException
         */
        private boolean addGeneratedRootClassToSWFFrame(SWFFrame frame, ISWF swf, ModuleFactoryInfo moduleFactoryInfo, 
                ImmutableSet<ICompilationUnit> emittedCompilationUnits, 
                Collection<ICompilerProblem> problemCollection) throws InterruptedException
        {
            ABCEmitter emitter = new ABCEmitter();
            emitter.visit(ABCConstants.VERSION_ABC_MAJOR_FP10, ABCConstants.VERSION_ABC_MINOR_FP10);
            

            final String generatedRootClassNameString = moduleFactoryInfo.generatedModuleFactoryClassName;

            Name generatedRootName = new Name(generatedRootClassNameString);
            
            // Generate code for the constructor:
            // public function ClassName()
            // {
            //    super();
            // }
            InstructionList classITraitsInit = new InstructionList();
            classITraitsInit.addInstruction(ABCConstants.OP_getlocal0);
            classITraitsInit.addInstruction(ABCConstants.OP_constructsuper, 0);
            classITraitsInit.addInstruction(ABCConstants.OP_returnvoid);
            ClassGeneratorHelper classGen = new ClassGeneratorHelper(project,
                    emitter,
                    generatedRootName, 
                    (ClassDefinition)moduleFactoryInfo.moduleFactoryBaseClass,
                    Collections.<Name>emptyList(),
                    classITraitsInit);
            IResolvedQualifiersReference objectReference =
                ReferenceFactory.packageQualifiedReference(project.getWorkspace(), 
                    IASLanguageConstants.Object);
            
            // Codegen various methods
            // TODO: Determine whether a override is needed or not depending on the 
            // methods in the base class. Same deal for the Create and Info Methods.
            codegenCallInContextMethod(classGen, true);

            final RoyaleLibraryFrame1Info frame1Info =
                new RoyaleLibraryFrame1Info(royaleProject, emittedCompilationUnits);
            
            // Override the create() and info() methods if we have embedded fonts.
            if (!frame1Info.embeddedFonts.isEmpty())
            {
                codegenCreateMethod(classGen, objectReference.getMName(), true);
                codegenInfoMethod(classGen, 
                        IASLanguageConstants.Object,
                        frame1Info,
                        accessibleClassNames,
                        problemCollection);            
            }
            
            classGen.finishScript();

            DoABCTag doABC = new DoABCTag();
            try
            {
                doABC.setABCData(emitter.emit());
            }
            catch (Exception e)
            {
                return false;
            }

            doABC.setName(generatedRootClassNameString);
            frame.addTag(doABC);
            return true;
        }
        
        /**
         * Wrapping for the codegenInfoMethod.
         * Only exposing what library.swf needs.
         * 
         * @param classGen
         * @param rootClassQName
         * @param embeddedFonts
         * @param accessibleClassNames
         * @param problemCollection
         * @throws InterruptedException
         */
        private void codegenInfoMethod(ClassGeneratorHelper classGen, 
                String rootClassQName, 
                RoyaleFrame1Info frame1Info, 
                Set<String> accessibleClassNames, 
                Collection<ICompilerProblem> problemCollection) throws InterruptedException
        {
            codegenInfoMethod(classGen, 
                    null,
                    rootClassQName,
                    null, // preloader
                    null, // runtimeDPI
                    null, // splash screen
                    null, // root node
                    null, // target attributes
                    null, // locales
                    frame1Info,
                    accessibleClassNames,
                    null, // royale init
                    null, // styles class name
                    null, // rsls
                    null, // rslinof
                    problemCollection,
                    false, false, null);
            
        }
        
    }
    
    
}