/*
 * 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.netbeans.modules.projectimport.eclipse.core;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.prefs.Preferences;
import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.queries.CollocationQuery;
import org.netbeans.modules.projectimport.eclipse.core.spi.ProjectImportModel;
import org.netbeans.modules.projectimport.eclipse.core.spi.ProjectTypeFactory;
import org.netbeans.modules.projectimport.eclipse.core.spi.ProjectTypeUpdater;
import org.netbeans.spi.project.support.ant.PropertyUtils;
import org.openide.filesystems.FileUtil;
import org.openide.util.Exceptions;
import org.openide.util.NbPreferences;

/**
 * Represents reference to Eclipse project which consist of eclipse project location,
 * eclipse workspace location, eclipse files timestamp and key identifying relevant 
 * import data. File references are stored relative if collocated. If differnt user
 * opens NetBeans project and Eclipse reference cannot be resolved then UI asking 
 * for eclipse project location and eclipse workspace location is shown. These
 * are stored in NbPreferences in userdir for now.
 */
public class EclipseProjectReference {

    private Project project;
    private final File eclipseProjectLocation;
    private final File eclipseWorkspaceLocation;
    private long timestamp;
    private String key;
    
    private boolean initialized;
    private EclipseProject eclipseProject;
    private ProjectImportModel importModel;
    
    private final static String PROJECT_PREFIX = "project-"; //NOI18N
    private final static String WORKSPACE_PREFIX = "workspace-"; //NOI18N
    
    public EclipseProjectReference(Project project, String eclipseProjectLocation, String eclipseWorkspaceLocation, long timestamp, String key) {
        this.eclipseProjectLocation = PropertyUtils.resolveFile(FileUtil.toFile(project.getProjectDirectory()), eclipseProjectLocation);
        if (eclipseWorkspaceLocation != null) {
            this.eclipseWorkspaceLocation = PropertyUtils.resolveFile(FileUtil.toFile(project.getProjectDirectory()), eclipseWorkspaceLocation);
        } else {
            this.eclipseWorkspaceLocation = null;
        }
        this.timestamp = timestamp;
        this.key = key;
        this.project = project;
    }

    Project getProject() {
        return project;
    }
    
    public @NonNull File getEclipseProjectLocation() {
        return eclipseProjectLocation;
    }

    public @CheckForNull File getEclipseWorkspaceLocation() {
        return eclipseWorkspaceLocation;
    }
    
    File getFallbackEclipseProjectLocation() {
        String path = getPreferences().get(PROJECT_PREFIX+getEclipseProjectLocation().getPath(), null);
        if (path != null) {
            return new File(path);
        }
        return getEclipseProjectLocation();
    }

    File getFallbackWorkspaceProjectLocation() {
        if (eclipseWorkspaceLocation == null) {
            return null;
        }
        String path = getPreferences().get(WORKSPACE_PREFIX+getEclipseWorkspaceLocation().getPath(), null);
        if (path != null) {
            return FileUtil.normalizeFile(new File(path));
        }
        return getEclipseWorkspaceLocation();
    }

    void updateReference(String eclipseLocation, String eclipseWorkspace) {
        if (eclipseLocation != null) {
            getPreferences().put(PROJECT_PREFIX+getEclipseProjectLocation().getPath(), eclipseLocation); //NOI18N
        }
        if (eclipseWorkspace != null) {
            getPreferences().put(WORKSPACE_PREFIX+getEclipseWorkspaceLocation().getPath(), eclipseWorkspace); //NOI18N
        }
    }
    
    private static Preferences getPreferences() {
        return NbPreferences.forModule(EclipseProjectReference.class);
    }

    public static @CheckForNull EclipseProjectReference read(Project project) {
        // XXX using shared prefs is incorrect if an absolute path was stored!
        Preferences prefs = ProjectUtils.getPreferences(project, EclipseProjectReference.class, true);
        String projectLoc = prefs.get("project", null); //NOI18N
        if (projectLoc == null) {
            return null;
        }
        return new EclipseProjectReference(project, projectLoc, prefs.get("workspace", null), Long.parseLong(prefs.get("timestamp", null)), prefs.get("key", null)); //NOI18N
    }
    
    public static void write(Project project, EclipseProjectReference ref) {
        Preferences prefs = ProjectUtils.getPreferences(project, EclipseProjectReference.class, true);
        File baseDir = FileUtil.toFile(project.getProjectDirectory());
        if (CollocationQuery.areCollocated(baseDir, ref.eclipseProjectLocation)) {
            prefs.put("project", PropertyUtils.relativizeFile(baseDir, ref.eclipseProjectLocation)); //NOI18N
        } else {
            prefs.put("project", ref.eclipseProjectLocation.getPath()); //NOI18N
        }
        if (ref.eclipseWorkspaceLocation != null) {
            if (CollocationQuery.areCollocated(baseDir, ref.eclipseWorkspaceLocation)) {
                prefs.put("workspace", PropertyUtils.relativizeFile(baseDir, ref.eclipseWorkspaceLocation)); //NOI18N
            } else {
                prefs.put("workspace", ref.eclipseWorkspaceLocation.getPath()); //NOI18N
            }
        }
        prefs.put("timestamp", Long.toString(ref.getCurrentTimestamp())); //NOI18N
        prefs.put("key", ref.key); //NOI18N
    }

    /**
     * @param deepTest if false only file timestamps are compared; if false 
     *  project classpath is compared
     */
    public boolean isUpToDate(boolean deepTest) {
        if (getCurrentTimestamp() > timestamp) {
            return false;
        } else if (!deepTest) {
            return true;
        }
        EclipseProject ep = getEclipseProject(true);
        if (ep == null) {
            // an exception was thrown; pretend proj is uptodate
            return true;
        }
        if (!(ep.getProjectTypeFactory() instanceof ProjectTypeUpdater)) {
            assert false : "project with <eclipse> data in project.xml is upgradable: "+ //NOI18N
                    project.getProjectDirectory()+" " +ep.getProjectTypeFactory().getClass().getName(); //NOI18N
        }
        ProjectTypeUpdater updater = (ProjectTypeUpdater)ep.getProjectTypeFactory();
        return key.equals(updater.calculateKey(importModel));
    }

    void update(List<String> importProblems) throws IOException {
        EclipseProject ep = getEclipseProject(true);
        if (ep == null) {
            // an exception was thrown; pretend proj is uptodate
            return;
        }
        ProjectTypeFactory factory = ep.getProjectTypeFactory();
        if (!(factory instanceof ProjectTypeUpdater)) {
            assert false : "project with <eclipse> data in project.xml is upgradable"; //NOI18N
            return;
        }
        
        // resolve classpath containers
        ep.resolveContainers(importProblems, true);
        
        // create ENV variables in build.properties
        ep.setupEnvironmentVariables(importProblems);
        
        // perform update
        key = ((ProjectTypeUpdater) factory).update(project, importModel, key, importProblems);
        write(project, this);
    }

    private long getCurrentTimestamp() {
        // use directly Files:
        File dotClasspath = new File(getFallbackEclipseProjectLocation(), ".classpath"); //NOI18N
        File dotProject = new File(getFallbackEclipseProjectLocation(), ".project"); //NOI18N
        return Math.max(dotClasspath.lastModified(), dotProject.lastModified());
    }
    
    boolean isEclipseProjectReachable() {
        boolean b = EclipseUtils.isRegularProject(eclipseProjectLocation) &&
                (eclipseWorkspaceLocation == null || 
                 (eclipseWorkspaceLocation != null && EclipseUtils.isRegularWorkSpace(eclipseWorkspaceLocation)));
        if (b) {
            // if project/workspace are reachable remove fallback properties
            getPreferences().remove(PROJECT_PREFIX+eclipseProjectLocation.getPath());
            if (eclipseWorkspaceLocation != null) {
                getPreferences().remove(WORKSPACE_PREFIX+eclipseWorkspaceLocation.getPath());
            }
            return true;
        }
        return EclipseUtils.isRegularProject(getFallbackEclipseProjectLocation()) &&
                (eclipseWorkspaceLocation == null ||
                 (eclipseWorkspaceLocation != null && EclipseUtils.isRegularWorkSpace(getFallbackWorkspaceProjectLocation())));
    }

    public EclipseProject getEclipseProject(boolean forceReload) {
        if (forceReload || !initialized) {
            try {
                EclipseProject ep = null;
                if (getFallbackWorkspaceProjectLocation() != null) {
                    Workspace w = WorkspaceFactory.getInstance().load(getFallbackWorkspaceProjectLocation());
                    ep = w.getProjectByProjectDir(getFallbackEclipseProjectLocation());
                }
                if (ep == null) {
                    ep = ProjectFactory.getInstance().load(getFallbackEclipseProjectLocation(), getFallbackWorkspaceProjectLocation());
                }
                eclipseProject = ep;
            } catch (ProjectImporterException ex) {
                Exceptions.printStackTrace(ex);
                eclipseProject = null;
                initialized = true;
                return null;
            }
            File f = FileUtil.toFile(project.getProjectDirectory());
            importModel = new ProjectImportModel(eclipseProject, f, 
                    JavaPlatformSupport.getJavaPlatformSupport().getJavaPlatform(eclipseProject, new ArrayList<String>()), Collections.<Project>emptyList());
            initialized = true;
        }
        return eclipseProject;
    }
}