/**
 * Copyright (c) 2010 Symbian Foundation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of the License "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 *
 * Initial Contributors:
 * Symbian Foundation - initial contribution.
 * Contributors:
 * Description:
 * Overview:
 * Details:
 * Platforms/Drives/Compatibility:
 * Assumptions/Requirement/Pre-requisites:
 * Failures and causes:
 */
package org.symbian.tools.tmw.internal.ui.project;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.symbian.tools.tmw.internal.util.DelegateRunnable;
import org.symbian.tools.tmw.ui.project.IProjectTemplateContext;
import org.symbian.tools.tmw.ui.project.ITemplateInstaller;

public class CompoundInstaller implements ITemplateInstaller {
    private final class InstallerFiles {
        private final ITemplateInstaller installer;
        private final Collection<IPath> paths;

        public InstallerFiles(Collection<IPath> paths, ITemplateInstaller installer) {
            this.paths = paths;
            this.installer = installer;
        }
    }

    public static ITemplateInstaller combine(ITemplateInstaller installer, IConfigurationElement[] elements) {
        final ITemplateInstaller[] installers = getChildren(installer);
        final Collection<ITemplateInstaller> installerCollection = new ArrayList<ITemplateInstaller>(installers.length
                + elements.length);
        installerCollection.addAll(Arrays.asList(installers));
        installerCollection.addAll(fromExtensions(elements));
        return new CompoundInstaller(installerCollection.toArray(new ITemplateInstaller[installerCollection.size()]));
    }

    public static ITemplateInstaller combine(ITemplateInstaller installer1, ITemplateInstaller installer2) {
        final ITemplateInstaller[] children1 = getChildren(installer1);
        final ITemplateInstaller[] children2 = getChildren(installer2);
        final ITemplateInstaller[] result = new ITemplateInstaller[children1.length + children2.length];
        System.arraycopy(children1, 0, result, 0, children1.length);
        System.arraycopy(children2, 0, result, children1.length, children2.length);
        return new CompoundInstaller(result);
    }

    private static Collection<? extends ITemplateInstaller> fromExtensions(IConfigurationElement[] elements) {
        final Collection<ITemplateInstaller> result = new LinkedList<ITemplateInstaller>();
        for (IConfigurationElement element : elements) {
            if ("installer".equals(element.getName())) {
                result.add(new LazyInstaller(element));
            } else if ("archive".equals(element.getName())) {
                result.add(new ZipInstaller(element));
            }
        }
        return result;
    }

    private static ITemplateInstaller[] getChildren(ITemplateInstaller installer) {
        final ITemplateInstaller[] installers;
        if (installer == null) {
            installers = new ITemplateInstaller[0];
        } else if (installer instanceof CompoundInstaller) {
            installers = ((CompoundInstaller) installer).installers;
        } else {
            installers = new ITemplateInstaller[] { installer };
        }
        return installers;
    }

    private final Collection<InstallerFiles> files = new LinkedList<CompoundInstaller.InstallerFiles>();
    private final ITemplateInstaller[] installers;

    private CompoundInstaller(ITemplateInstaller[] installers) {
        this.installers = installers;
    }

    public void cleanup() {
        for (ITemplateInstaller installer : installers) {
            installer.cleanup();
        }
    }

    public void copyFiles(IPath[] files, IProgressMonitor monitor) throws CoreException {
        monitor.beginTask("Copying files", files.length * 10);
        final List<IPath> list = Arrays.asList(files);
        for (InstallerFiles fs : this.files) {
            final ITemplateInstaller installer = fs.installer;
            fs.paths.retainAll(list);
            IPath[] array = fs.paths.toArray(new IPath[fs.paths.size()]);
            installer.copyFiles(array, new SubProgressMonitor(monitor, array.length * 10));
        }
        monitor.done();
    }

    public IPath[] getFiles() throws CoreException {
        final Collection<IPath> paths = new HashSet<IPath>();
        for (ITemplateInstaller installer : installers) {
            final IPath[] f = installer.getFiles();
            final Collection<IPath> c = new HashSet<IPath>(Arrays.asList(f));
            c.removeAll(paths);
            files.add(new InstallerFiles(c, installer));
            paths.addAll(c);
        }
        return paths.toArray(new IPath[paths.size()]);
    }

    public void prepare(IProject project, IProjectTemplateContext context) {
        for (ITemplateInstaller installer : installers) {
            installer.prepare(project, context);
        }
    }

    public IRunnableWithProgress getPostCreateAction() {
        final Collection<IRunnableWithProgress> runnables = new LinkedList<IRunnableWithProgress>();
        for (ITemplateInstaller installer : installers) {
            final IRunnableWithProgress action = installer.getPostCreateAction();
            if (action != null) {
                runnables.add(action);
            }
        }
        return runnables.size() > 0 ? new DelegateRunnable(runnables) : null;
    }
}