/*
 *  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.ivy.plugins.resolver;

import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.ivy.core.IvyPatternHelper;
import org.apache.ivy.core.module.descriptor.Artifact;
import org.apache.ivy.core.module.id.ModuleRevisionId;
import org.apache.ivy.core.settings.IvyPattern;
import org.apache.ivy.plugins.repository.file.FileRepository;
import org.apache.ivy.util.Checks;
import org.apache.ivy.util.Message;

/**
 */
public class FileSystemResolver extends RepositoryResolver {

    private static final String TRANSACTION_DESTINATION_SUFFIX = ".part";
    private static final Pattern TRANSACTION_PATTERN = 
        Pattern.compile("(.*[/\\\\]\\[revision\\])([/\\\\].+)");
    
    /**
     * Transactional mode.
     * 
     * auto: use transaction if possible, only log verbose message if not
     * true: always use transaction, fail if not supported
     * false: never use transactions
     */
    private String transactional = "auto"; // one of 'auto', 'true' or 'false'
    
    /**
     * When set indicates if this resolver supports transaction
     */
    private Boolean supportTransaction;
    /**
     * The pattern leading to the directory where files are published before being moved at the end
     * of a transaction
     */
    private String baseTransactionPattern;
    /**
     * Map between actual patterns and patterns used during the transaction to put files in a
     * temporary directory
     */
    private Map/*<String,String>*/ fullTransactionPatterns = new HashMap();

    /**
     * Location where files are published during the transaction
     */
    private File transactionTempDir;
    /**
     * Location where files should end up at the end of the transaction
     */
    private File transactionDestDir;
    
    public FileSystemResolver() {
        setRepository(new FileRepository());
    }
    
    public String getTypeName() {
        return "file";
    }

    public boolean isLocal() {
        return getFileRepository().isLocal();
    }

    public void setLocal(boolean local) {
        getFileRepository().setLocal(local);
    }

    private FileRepository getFileRepository() {
        return (FileRepository) getRepository();
    }
    

    protected String getDestination(String pattern, Artifact artifact, ModuleRevisionId mrid) {
        if (supportTransaction() && isTransactionStarted()) {
            
            String destPattern = (String) fullTransactionPatterns.get(pattern);
            if (destPattern == null) {
                throw new IllegalArgumentException(
                    "unsupported pattern for publish destination pattern: " + pattern 
                    + ". supported patterns: " + fullTransactionPatterns.keySet());
            }
            return IvyPatternHelper.substitute(
                destPattern, 
                mrid, 
                artifact);
        } else {
            return super.getDestination(pattern, artifact, mrid);
        }
    }

    private boolean isTransactionStarted() {
        return transactionTempDir != null;
    }

    public void abortPublishTransaction() throws IOException {
        if (supportTransaction()) {
            if (isTransactionStarted()) {                
                try {
                    getFileRepository().delete(transactionTempDir);
                    Message.info("\tpublish aborted: deleted " + transactionTempDir);
                } finally {
                    closeTransaction();
                }
            } else { 
                Message.info("\tpublish aborted: nothing was started");                
            }
        }
    }

    public void commitPublishTransaction() throws IOException {
        if (supportTransaction()) {
            if (!isTransactionStarted()) {
                throw new IllegalStateException("no current transaction!");
            }
            if (transactionDestDir.exists()) {
                throw new IOException(
                    "impossible to commit transaction: transaction destination directory "
                    + "already exists: " + transactionDestDir
                    + "\npossible cause: usage of identifying tokens after the revision token");
            }
            try {
                getFileRepository().move(transactionTempDir, transactionDestDir);
                
                Message.info("\tpublish commited: moved " + transactionTempDir 
                    + " \n\t\tto " + transactionDestDir);
            } catch (IOException ex) {
                IOException commitEx;
                try {
                    getFileRepository().delete(transactionTempDir);
                    commitEx = new IOException(
                        "publish transaction commit error for " + transactionDestDir 
                        + ": rolled back");
                } catch (IOException deleteEx) {
                    commitEx = new IOException(
                        "publish transaction commit error for " + transactionDestDir 
                        + ": rollback impossible either, "
                        + "please remove " + transactionTempDir + " manually");
                }
                commitEx.initCause(ex);
                throw commitEx;
            } finally {
                closeTransaction();
            }
        }
    }

    public void beginPublishTransaction(
            ModuleRevisionId module, boolean overwrite) throws IOException {
        if (supportTransaction()) {
            if (isTransactionStarted()) {
                throw new IllegalStateException("a transaction is already started and not closed!");
            }
            if (overwrite) {
                unsupportedTransaction("overwrite transaction not supported yet");
            } else {
                initTransaction(module);
                if (transactionDestDir.exists()) {
                    unsupportedTransaction(
                        "transaction destination directory already exists: " + transactionDestDir
                        + "\npossible cause: usage of identifying tokens after the revision token");
                    closeTransaction();
                } else {
                    Message.verbose(
                        "\tstarting transaction: publish during transaction will be done in \n\t\t" 
                        + transactionTempDir 
                        + "\n\tand on commit moved to \n\t\t" + transactionDestDir);
                }
            }
        }
    }
    
    protected Collection filterNames(Collection values) {
        if (supportTransaction()) {
            values =  super.filterNames(values);
            for (Iterator iterator = values.iterator(); iterator.hasNext();) {
                String v = (String) iterator.next();
                if (v.endsWith(TRANSACTION_DESTINATION_SUFFIX)) {
                    iterator.remove();
                }
            }
            return values;
        } else {
            return super.filterNames(values);
        }
    }
    
    public boolean supportTransaction() {
        if ("false".equals(transactional)) {
            return false;
        }
        checkSupportTransaction();
        return supportTransaction.booleanValue();
    }

    private void closeTransaction() {
        transactionTempDir = null;
        transactionDestDir = null;
    }
    
    private void checkSupportTransaction() {
        if (supportTransaction == null) {
            supportTransaction = Boolean.FALSE;
            List ivyPatterns = getIvyPatterns();
            List artifactPatterns = getArtifactPatterns();
            
            if (ivyPatterns.size() > 0) {
                String pattern = (String) ivyPatterns.get(0);
                Matcher m = TRANSACTION_PATTERN.matcher(pattern);
                if (!m.matches()) {
                    unsupportedTransaction("ivy pattern does not use revision as a directory");
                    return;
                } else {
                    baseTransactionPattern = m.group(1);
                    fullTransactionPatterns.put(pattern, 
                        m.group(1) + TRANSACTION_DESTINATION_SUFFIX + m.group(2));
                }
            }
            if (artifactPatterns.size() > 0) {
                String pattern = (String) artifactPatterns.get(0);
                Matcher m = TRANSACTION_PATTERN.matcher(pattern);
                if (!m.matches()) {
                    unsupportedTransaction("artifact pattern does not use revision as a directory");
                    return;
                } else if (baseTransactionPattern != null) {
                    if (!baseTransactionPattern.equals(m.group(1))) {
                        unsupportedTransaction("ivy pattern and artifact pattern "
                            + "do not use the same directory for revision");
                        return;
                    } else {
                        fullTransactionPatterns.put(pattern, 
                            m.group(1) + TRANSACTION_DESTINATION_SUFFIX + m.group(2));
                    }
                } else {
                    baseTransactionPattern = m.group(1);
                    fullTransactionPatterns.put(pattern, 
                        m.group(1) + TRANSACTION_DESTINATION_SUFFIX + m.group(2));
                }
            }
            supportTransaction = Boolean.TRUE;
        }
    }

    private void unsupportedTransaction(String msg) {
        String fullMsg = getName() + " do not support transaction. " + msg;
        if ("true".equals(transactional)) {
            throw new IllegalStateException(fullMsg 
                + ". Set transactional attribute to 'auto' or 'false' or fix the problem.");
        } else {
            Message.verbose(fullMsg);
            supportTransaction = Boolean.FALSE;
        }
    }

    private void initTransaction(ModuleRevisionId module) {
        ModuleRevisionId mrid = module;
        if (isM2compatible()) {
            mrid = convertM2IdForResourceSearch(module);
        }
        
        transactionTempDir = Checks.checkAbsolute(IvyPatternHelper.substitute(
            baseTransactionPattern, 
            ModuleRevisionId.newInstance(
                mrid, mrid.getRevision() + TRANSACTION_DESTINATION_SUFFIX)),
                "baseTransactionPattern");
        transactionDestDir = Checks.checkAbsolute(IvyPatternHelper.substitute(
            baseTransactionPattern, mrid), "baseTransactionPattern");
    }

    public String getTransactional() {
        return transactional;
    }

    public void setTransactional(String transactional) {
        this.transactional = transactional;
    }

    public void addConfiguredIvy(IvyPattern p) {
        File file = Checks.checkAbsolute(p.getPattern(), "ivy pattern");
        p.setPattern(file.getAbsolutePath());
        super.addConfiguredIvy(p);
    }
    
    public void addIvyPattern(String pattern) {
        File file = Checks.checkAbsolute(pattern, "ivy pattern");
        super.addIvyPattern(file.getAbsolutePath());
    }
    
    public void addConfiguredArtifact(IvyPattern p) {
        File file = Checks.checkAbsolute(p.getPattern(), "artifact pattern");
        p.setPattern(file.getAbsolutePath());
        super.addConfiguredArtifact(p);
    }
    
    public void addArtifactPattern(String pattern) {
        File file = Checks.checkAbsolute(pattern, "artifact pattern");
        super.addArtifactPattern(file.getAbsolutePath());
    }
}
