/*
 *  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
 *
 *      https://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.repository.vsftp;

import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.regex.Pattern;

import org.apache.ivy.Ivy;
import org.apache.ivy.core.IvyContext;
import org.apache.ivy.core.IvyThread;
import org.apache.ivy.core.event.IvyEvent;
import org.apache.ivy.core.event.IvyListener;
import org.apache.ivy.core.event.resolve.EndResolveEvent;
import org.apache.ivy.core.settings.TimeoutConstraint;
import org.apache.ivy.plugins.repository.AbstractRepository;
import org.apache.ivy.plugins.repository.BasicResource;
import org.apache.ivy.plugins.repository.Resource;
import org.apache.ivy.plugins.repository.TransferEvent;
import org.apache.ivy.util.Checks;
import org.apache.ivy.util.Message;

/**
 * Repository using SecureCRT vsftp command line program to access an sftp repository This is
 * especially useful to leverage the gssapi authentication supported by SecureCRT. In cases where
 * usual sftp is enough, prefer the 100% java solution of sftp repository. This requires SecureCRT
 * to be in the PATH. Tested with SecureCRT 5.0.5
 */
public class VsftpRepository extends AbstractRepository {
    private static final int LS_DATE_INDEX4 = 7;

    private static final int LS_DATE_INDEX3 = 6;

    private static final int LS_DATE_INDEX2 = 5;

    private static final int LS_DATE_INDEX1 = 4;

    private static final int LS_SIZE_INDEX = 3;

    private static final int LS_PARTS_NUMBER = 9;

    private static final int DISCONNECT_COMMAND_TIMEOUT = 300;

    private static final int REUSE_CONNECTION_SLEEP_TIME = 10;

    private static final int READER_ALIVE_SLEEP_TIME = 100;

    private static final int MAX_READER_ALIVE_ATTEMPT = 5;

    private static final int ERROR_SLEEP_TIME = 30;

    private static final int PROMPT_SLEEP_TIME = 50;

    private static final int MAX_READ_PROMPT_ATTEMPT = 5;

    private static final int GET_JOIN_MAX_TIME = 100;

    private static final int DEFAULT_REUSE_CONNECTION_TIME = 300000;

    // reuse connection during 5 minutes by default

    private static final int DEFAULT_READ_TIMEOUT = 30000;

    private static final String PROMPT = "vsftp> ";

    private static final SimpleDateFormat FORMAT = new SimpleDateFormat("MMM dd, yyyy HH:mm",
            Locale.US);

    private String host;

    private String username;

    private String authentication = "gssapi";

    private Reader in;

    private Reader err;

    private PrintWriter out;

    private volatile StringBuilder errors = new StringBuilder();

    private long readTimeout = DEFAULT_READ_TIMEOUT;

    private long reuseConnection = DEFAULT_REUSE_CONNECTION_TIME;

    private volatile long lastCommand;

    private volatile boolean inCommand;

    private Process process;

    private Thread connectionCleaner;

    private Thread errorsReader;

    private volatile long errorsLastUpdateTime;

    private Ivy ivy = null;

    public VsftpRepository() {
    }

    public VsftpRepository(final TimeoutConstraint timeoutConstraint) {
        super(timeoutConstraint);
    }

    public Resource getResource(String source) throws IOException {
        initIvy();
        return new VsftpResource(this, source);
    }

    private void initIvy() {
        ivy = IvyContext.getContext().getIvy();
    }

    protected Resource getInitResource(String source) throws IOException {
        try {
            return lslToResource(source, sendCommand("ls -l " + source, true, true));
        } catch (IOException ex) {
            cleanup(ex);
            throw ex;
        } finally {
            cleanup();
        }
    }

    public void get(final String source, File destination) throws IOException {
        initIvy();
        try {
            fireTransferInitiated(getResource(source), TransferEvent.REQUEST_GET);
            File destDir = destination.getParentFile();
            if (destDir != null) {
                sendCommand("lcd " + destDir.getAbsolutePath());
            }
            if (destination.exists()) {
                destination.delete();
            }

            int index = source.lastIndexOf('/');
            String srcName = (index == -1) ? source : source.substring(index + 1);
            final File to = (destDir == null) ? Checks.checkAbsolute(srcName, "source")
                    : new File(destDir, srcName);

            final IOException[] ex = new IOException[1];
            Thread get = new IvyThread() {
                public void run() {
                    initContext();
                    try {
                        sendCommand("get " + source, getExpectedDownloadMessage(source, to), 0);
                    } catch (IOException e) {
                        ex[0] = e;
                    }
                }
            };
            get.start();

            long prevLength = 0;
            long lastUpdate = System.currentTimeMillis();
            long timeout = readTimeout;
            while (get.isAlive()) {
                checkInterrupted();
                long length = to.exists() ? to.length() : 0;
                if (length > prevLength) {
                    fireTransferProgress(length - prevLength);
                    lastUpdate = System.currentTimeMillis();
                    prevLength = length;
                } else {
                    if (System.currentTimeMillis() - lastUpdate > timeout) {
                        Message.verbose("download hang for more than " + timeout
                                + "ms. Interrupting.");
                        get.interrupt();
                        if (to.exists()) {
                            to.delete();
                        }
                        throw new IOException(source + " download timeout from " + getHost());
                    }
                }
                try {
                    get.join(GET_JOIN_MAX_TIME);
                } catch (InterruptedException e) {
                    if (to.exists()) {
                        to.delete();
                    }
                    return;
                }
            }
            if (ex[0] != null) {
                if (to.exists()) {
                    to.delete();
                }
                throw ex[0];
            }

            to.renameTo(destination);
            fireTransferCompleted(destination.length());
        } catch (IOException ex) {
            fireTransferError(ex);
            cleanup(ex);
            throw ex;
        } finally {
            cleanup();
        }
    }

    public List<String> list(String parent) throws IOException {
        initIvy();
        try {
            if (!parent.endsWith("/")) {
                parent += "/";
            }
            String response = sendCommand("ls -l " + parent, true, true);
            if (response.startsWith("ls")) {
                return null;
            }
            String[] lines = response.split("\n");
            List<String> ret = new ArrayList<>(lines.length);
            for (String line : lines) {
                while (line.endsWith("\r") || line.endsWith("\n")) {
                    line = line.substring(0, line.length() - 1);
                }
                if (!line.trim().isEmpty()) {
                    ret.add(parent + line.substring(line.lastIndexOf(' ') + 1));
                }
            }
            return ret;
        } catch (IOException ex) {
            cleanup(ex);
            throw ex;
        } finally {
            cleanup();
        }
    }

    public void put(File source, String destination, boolean overwrite) throws IOException {
        initIvy();
        try {
            if (getResource(destination).exists()) {
                if (overwrite) {
                    sendCommand("rm " + destination, getExpectedRemoveMessage(destination));
                } else {
                    return;
                }
            }
            int index = destination.lastIndexOf('/');
            String destDir = null;
            if (index != -1) {
                destDir = destination.substring(0, index);
                mkdirs(destDir);
                sendCommand("cd " + destDir);
            }
            String to = destDir != null ? destDir + "/" + source.getName() : source.getName();
            sendCommand("put " + source.getAbsolutePath(), getExpectedUploadMessage(source, to), 0);
            sendCommand("mv " + to + " " + destination);
        } catch (IOException ex) {
            cleanup(ex);
            throw ex;
        } finally {
            cleanup();
        }
    }

    private void mkdirs(String destDir) throws IOException {
        if (dirExists(destDir)) {
            return;
        }
        if (destDir.endsWith("/")) {
            destDir = destDir.substring(0, destDir.length() - 1);
        }
        int index = destDir.lastIndexOf('/');
        if (index != -1) {
            mkdirs(destDir.substring(0, index));
        }
        sendCommand("mkdir " + destDir);
    }

    private boolean dirExists(String dir) throws IOException {
        return !sendCommand("ls " + dir, true).startsWith("ls: ");
    }

    protected String sendCommand(String command) throws IOException {
        return sendCommand(command, false, readTimeout);
    }

    protected void sendCommand(String command, Pattern expectedResponse) throws IOException {
        sendCommand(command, expectedResponse, readTimeout);
    }

    /**
     * The behaviour of vsftp with some commands is to log the resulting message on the error
     * stream, even if everything is ok. So it's quite difficult if there was an error or not. Hence
     * we compare the response with the expected message and deal with it. The problem is that this
     * is very specific to the version of vsftp used for the test, That's why expected messages are
     * obtained using overriddable protected methods.
     *
     * @param command String
     * @param expectedResponse Pattern
     * @param timeout long
     * @throws IOException if something goes wrong
     */
    protected void sendCommand(String command, Pattern expectedResponse, long timeout)
            throws IOException {
        String response = sendCommand(command, true, timeout);
        if (!expectedResponse.matcher(response).matches()) {
            Message.debug("invalid response from server:");
            Message.debug("expected: '" + expectedResponse + "'");
            Message.debug("was:      '" + response + "'");
            throw new IOException(response);
        }
    }

    protected String sendCommand(String command, boolean sendErrorAsResponse) throws IOException {
        return sendCommand(command, sendErrorAsResponse, readTimeout);
    }

    protected String sendCommand(String command, boolean sendErrorAsResponse, boolean single)
            throws IOException {
        return sendCommand(command, sendErrorAsResponse, single, readTimeout);
    }

    protected String sendCommand(String command, boolean sendErrorAsResponse, long timeout)
            throws IOException {
        return sendCommand(command, sendErrorAsResponse, false, timeout);
    }

    protected String sendCommand(String command, boolean sendErrorAsResponse, boolean single,
            long timeout) throws IOException {
        single = false; // use of alone commands does not work properly due to a long delay between
        // end of process and end of stream...

        checkInterrupted();
        inCommand = true;
        errorsLastUpdateTime = 0;
        synchronized (this) {
            if (!single || in != null) {
                ensureConnectionOpened();
                Message.debug("sending command '" + command + "' to " + getHost());
                updateLastCommandTime();
                out.println(command);
                out.flush();
            } else {
                sendSingleCommand(command);
            }
        }

        try {
            return readResponse(sendErrorAsResponse, timeout);
        } finally {
            inCommand = false;
            if (single) {
                closeConnection();
            }
        }
    }

    protected String readResponse(boolean sendErrorAsResponse) throws IOException {
        return readResponse(sendErrorAsResponse, readTimeout);
    }

    @SuppressWarnings("deprecation")
    protected synchronized String readResponse(final boolean sendErrorAsResponse, long timeout)
            throws IOException {
        final StringBuilder response = new StringBuilder();
        final IOException[] exc = new IOException[1];
        final boolean[] done = new boolean[1];
        Runnable r = new Runnable() {
            public void run() {
                synchronized (VsftpRepository.this) {
                    try {
                        int c;
                        boolean getPrompt = false;
                        // the reading is done in a loop making five attempts to read the stream
                        // if we do not reach the next prompt
                        int attempt = 0;
                        while (!getPrompt && attempt < MAX_READ_PROMPT_ATTEMPT) {
                            while ((c = in.read()) != -1) {
                                // we managed to read something, reset number of attempts
                                attempt = 0;
                                response.append((char) c);
                                if (response.length() >= PROMPT.length()
                                        && response.substring(response.length() - PROMPT.length(),
                                            response.length()).equals(PROMPT)) {
                                    response.setLength(response.length() - PROMPT.length());
                                    getPrompt = true;
                                    break;
                                }
                            }
                            if (!getPrompt) {
                                try {
                                    Thread.sleep(PROMPT_SLEEP_TIME);
                                } catch (InterruptedException e) {
                                    break;
                                }
                            }
                            attempt++;
                        }
                        if (getPrompt) {
                            // wait enough for error stream to be fully read
                            if (errorsLastUpdateTime == 0) {
                                // no error written yet, but it may be pending...
                                errorsLastUpdateTime = lastCommand;
                            }

                            while ((System.currentTimeMillis() - errorsLastUpdateTime) < PROMPT_SLEEP_TIME) {
                                try {
                                    Thread.sleep(ERROR_SLEEP_TIME);
                                } catch (InterruptedException e) {
                                    break;
                                }
                            }
                        }
                        if (errors.length() > 0) {
                            if (sendErrorAsResponse) {
                                response.append(errors);
                                errors.setLength(0);
                            } else {
                                throw new IOException(chomp(errors).toString());
                            }
                        }
                        chomp(response);
                        done[0] = true;
                    } catch (IOException e) {
                        exc[0] = e;
                    } finally {
                        VsftpRepository.this.notify();
                    }
                }
            }
        };
        Thread reader = null;
        if (timeout == 0) {
            r.run();
        } else {
            reader = new IvyThread(r);
            reader.start();
            try {
                wait(timeout);
            } catch (InterruptedException e) {
                // nothing to do
            }
        }
        updateLastCommandTime();
        if (exc[0] != null) {
            throw exc[0];
        } else if (!done[0]) {
            if (reader != null && reader.isAlive()) {
                reader.interrupt();
                int attempt = 0;
                while (attempt < MAX_READER_ALIVE_ATTEMPT && reader.isAlive()) {
                    try {
                        Thread.sleep(READER_ALIVE_SLEEP_TIME);
                    } catch (InterruptedException e) {
                        break;
                    }
                    attempt++;
                }
                if (reader.isAlive()) {
                    reader.stop(); // no way to interrupt it non abruptly
                }
            }
            throw new IOException("connection timeout to " + getHost());
        } else {
            if ("Not connected.".equals(response.toString())) {
                Message.info("vsftp connection to " + getHost() + " reset");
                closeConnection();
                throw new IOException("not connected to " + getHost());
            }
            Message.debug("received response '" + response + "' from " + getHost());
            return response.toString();
        }
    }

    private synchronized void sendSingleCommand(String command) throws IOException {
        exec(getSingleCommand(command));
    }

    protected synchronized void ensureConnectionOpened() throws IOException {
        if (in == null) {
            Message.verbose("connecting to " + getUsername() + "@" + getHost() + "... ");
            String connectionCommand = getConnectionCommand();
            exec(connectionCommand);

            try {
                readResponse(false); // waits for first prompt

                if (reuseConnection > 0) {
                    connectionCleaner = new IvyThread() {
                        public void run() {
                            initContext();
                            try {
                                long sleep = REUSE_CONNECTION_SLEEP_TIME;
                                while (in != null && sleep > 0) {
                                    sleep(sleep);
                                    sleep = reuseConnection
                                            - (System.currentTimeMillis() - lastCommand);
                                    if (inCommand && sleep <= 0) {
                                        sleep = reuseConnection;
                                    }
                                }
                            } catch (InterruptedException e) {
                                // nothing to do
                            }
                            disconnect();
                        }
                    };
                    connectionCleaner.start();
                }

                if (ivy != null) {
                    ivy.getEventManager().addIvyListener(new IvyListener() {
                        public void progress(IvyEvent event) {
                            disconnect();
                            event.getSource().removeIvyListener(this);
                        }
                    }, EndResolveEvent.NAME);
                }

            } catch (IOException ex) {
                closeConnection();
                throw new IOException("impossible to connect to " + getUsername() + "@" + getHost()
                        + " using " + getAuthentication() + ": " + ex.getMessage());
            }
            Message.verbose("connected to " + getHost());
        }
    }

    private void updateLastCommandTime() {
        lastCommand = System.currentTimeMillis();
    }

    private void exec(String command) throws IOException {
        Message.debug("launching '" + command + "'");
        process = Runtime.getRuntime().exec(command);
        in = new InputStreamReader(process.getInputStream());
        err = new InputStreamReader(process.getErrorStream());
        out = new PrintWriter(process.getOutputStream());

        errorsReader = new IvyThread() {
            public void run() {
                initContext();
                int c;
                try {
                    // CheckStyle:InnerAssignment OFF
                    while (err != null && (c = err.read()) != -1) {
                        errors.append((char) c);
                        errorsLastUpdateTime = System.currentTimeMillis();
                    }
                    // CheckStyle:InnerAssignment ON
                } catch (IOException e) {
                    // nothing to do
                }
            }
        };
        errorsReader.start();
    }

    private void checkInterrupted() {
        if (ivy != null) {
            ivy.checkInterrupted();
        }
    }

    /**
     * Called whenever an api level method end
     */
    private void cleanup(Exception ex) {
        if (ex.getMessage().equals("connection timeout to " + getHost())) {
            closeConnection();
        } else {
            disconnect();
        }
    }

    /**
     * Called whenever an api level method end
     */
    private void cleanup() {
        if (reuseConnection == 0) {
            disconnect();
        }
    }

    public synchronized void disconnect() {
        if (in != null) {
            Message.verbose("disconnecting from " + getHost() + "... ");
            try {
                sendCommand("exit", false, DISCONNECT_COMMAND_TIMEOUT);
            } catch (IOException e) {
                // nothing I can do
            } finally {
                closeConnection();
                Message.verbose("disconnected of " + getHost());
            }
        }
    }

    private synchronized void closeConnection() {
        if (connectionCleaner != null) {
            connectionCleaner.interrupt();
        }
        if (errorsReader != null) {
            errorsReader.interrupt();
        }
        try {
            process.destroy();
        } catch (Exception ex) {
            // nothing I can do
        }
        try {
            in.close();
        } catch (Exception e) {
            // nothing I can do
        }
        try {
            err.close();
        } catch (Exception e) {
            // nothing I can do
        }
        try {
            out.close();
        } catch (Exception e) {
            // nothing I can do
        }

        connectionCleaner = null;
        errorsReader = null;
        process = null;
        in = null;
        out = null;
        err = null;
        Message.debug("connection to " + getHost() + " closed");
    }

    /**
     * Parses a ls -l line and transforms it in a resource
     *
     * @param file ditto
     * @param responseLine ditto
     * @return Resource
     */
    protected Resource lslToResource(String file, String responseLine) {
        if (responseLine == null || responseLine.startsWith("ls")) {
            return new BasicResource(file, false, 0, 0, false);
        } else {
            String[] parts = responseLine.split("\\s+");
            if (parts.length != LS_PARTS_NUMBER) {
                Message.debug("unrecognized ls format: " + responseLine);
                return new BasicResource(file, false, 0, 0, false);
            } else {
                try {
                    long contentLength = Long.parseLong(parts[LS_SIZE_INDEX]);
                    String date = parts[LS_DATE_INDEX1] + " " + parts[LS_DATE_INDEX2] + " "
                            + parts[LS_DATE_INDEX3] + " " + parts[LS_DATE_INDEX4];
                    return new BasicResource(file, true, contentLength, FORMAT.parse(date)
                            .getTime(), false);
                } catch (Exception ex) {
                    Message.warn("impossible to parse server response: " + responseLine, ex);
                    return new BasicResource(file, false, 0, 0, false);
                }
            }
        }
    }

    protected String getSingleCommand(String command) {
        return "vsh -noprompt -auth " + authentication + " " + username + "@" + host + " "
                + command;
    }

    protected String getConnectionCommand() {
        return "vsftp -noprompt -auth " + authentication + " " + username + "@" + host;
    }

    protected Pattern getExpectedDownloadMessage(String source, File to) {
        return Pattern.compile("Downloading " + to.getName() + " from [^\\s]+");
    }

    protected Pattern getExpectedRemoveMessage(String destination) {
        return Pattern.compile("Removing [^\\s]+");
    }

    protected Pattern getExpectedUploadMessage(File source, String to) {
        return Pattern.compile("Uploading " + source.getName() + " to [^\\s]+");
    }

    public String getAuthentication() {
        return authentication;
    }

    public void setAuthentication(String authentication) {
        this.authentication = authentication;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    private static StringBuilder chomp(StringBuilder str) {
        if (str == null || str.length() == 0) {
            return str;
        }
        while ("\n".equals(str.substring(str.length() - 1))
                || "\r".equals(str.substring(str.length() - 1))) {
            str.setLength(str.length() - 1);
        }
        return str;
    }

    public String toString() {
        return getName() + " " + getUsername() + "@" + getHost() + " (" + getAuthentication() + ")";
    }

    /**
     * Sets the reuse connection time. The same connection will be reused if the time here does not
     * last between two commands. O indicates that the connection should never be reused
     *
     * @param time long
     */
    public void setReuseConnection(long time) {
        this.reuseConnection = time;
    }

    public long getReadTimeout() {
        return readTimeout;
    }

    public void setReadTimeout(long readTimeout) {
        this.readTimeout = readTimeout;
    }
}
