/*
 * Copyright 2004-2009 H2 Group. Multiple-Licensed under the H2 License,
 * Version 1.0, and under the Eclipse Public License, Version 1.0
 * (http://h2database.com/html/license.html).
 * Initial Developer: H2 Group
 */
package org.h2.dev.ftp;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;

import org.h2.engine.Constants;
import org.h2.util.IOUtils;
import org.h2.util.NetUtils;
import org.h2.util.StringUtils;

/**
 * A simple standalone FTP client.
 */
public class FtpClient {
    private Socket socket;
    private BufferedReader reader;
    private PrintWriter writer;
    private int code;
    private String message;
    private Socket socketData;
    private InputStream inData;
    private OutputStream outData;

    private FtpClient() {
        // don't allow construction
    }

    /**
     * Open an FTP connection.
     *
     * @param url the FTP URL
     * @return the ftp client object
     */
    public static FtpClient open(String url) throws IOException {
        FtpClient client = new FtpClient();
        client.connect(url);
        return client;
    }

    private void connect(String url) throws IOException {
        socket = NetUtils.createSocket(url, 21, false);
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        reader = new BufferedReader(new InputStreamReader(in));
        writer = new PrintWriter(new OutputStreamWriter(out, Constants.UTF8));
        readCode(220);
    }

    private void readLine() throws IOException {
        while (true) {
            message = reader.readLine();
            if (message != null) {
                int idxSpace = message.indexOf(' ');
                int idxMinus = message.indexOf('-');
                int idx = idxSpace < 0 ? idxMinus : idxMinus < 0 ? idxSpace : Math.min(idxSpace, idxMinus);
                if (idx < 0) {
                    code = 0;
                } else {
                    code = Integer.parseInt(message.substring(0, idx));
                    message = message.substring(idx + 1);
                }
            }
            break;
        }
    }

    private void readCode(int optional, int expected) throws IOException {
        readLine();
        if (code == optional) {
            readLine();
        }
        if (code != expected) {
            throw new IOException("Expected: " + expected + " got: " + code + " " + message);
        }
    }

    private void readCode(int expected) throws IOException {
        readCode(-1, expected);
    }

    private void send(String command) {
        writer.println(command);
        writer.flush();
    }

    /**
     * Login to this FTP server (USER, PASS, SYST, SITE, STRU F, TYPE I).
     *
     * @param userName the user name
     * @param password the password
     */
    public void login(String userName, String password) throws IOException {
        send("USER " + userName);
        readCode(331);
        send("PASS " + password);
        readCode(230);
        send("SYST");
        readCode(215);
        send("SITE");
        readCode(500);
        send("STRU F");
        readCode(200);
        send("TYPE I");
        readCode(200);
    }

    /**
     * Close the connection (QUIT).
     */
    public void close() throws IOException {
        if (socket != null) {
            send("QUIT");
            readCode(221);
            socket.close();
        }
    }

    /**
     * Change the working directory (CWD).
     *
     * @param dir the new directory
     */
    public void changeWorkingDirectory(String dir) throws IOException {
        send("CWD " + dir);
        readCode(250);
    }

    /**
     * Change to the parent directory (CDUP).
     */
    public void changeDirectoryUp() throws IOException {
        send("CDUP");
        readCode(250);
    }

    /**
     * Delete a file (DELE).
     *
     * @param fileName the name of the file to delete
     */
    void delete(String fileName) throws IOException {
        send("DELE " + fileName);
        readCode(226, 250);
    }

    /**
     * Create a directory (MKD).
     *
     * @param dir the directory to create
     */
    public void makeDirectory(String dir) throws IOException {
        send("MKD " + dir);
        readCode(226, 257);
    }

    /**
     * Change the transfer mode (MODE).
     *
     * @param mode the mode
     */
    void mode(String mode) throws IOException {
        send("MODE " + mode);
        readCode(200);
    }

    /**
     * Change the modified time of a file (MDTM).
     *
     * @param fileName the file name
     */
    void modificationTime(String fileName) throws IOException {
        send("MDTM " + fileName);
        readCode(213);
    }

    /**
     * Issue a no-operation statement (NOOP).
     */
    void noOperation() throws IOException {
        send("NOOP");
        readCode(200);
    }

    /**
     * Print the working directory (PWD).
     *
     * @return the working directory
     */
    String printWorkingDirectory() throws IOException {
        send("PWD");
        readCode(257);
        return removeQuotes();
    }

    private String removeQuotes() {
        int first = message.indexOf('"') + 1;
        int last = message.lastIndexOf('"');
        StringBuffer buff = new StringBuffer();
        for (int i = first; i < last; i++) {
            char ch = message.charAt(i);
            buff.append(ch);
            if (ch == '\"') {
                i++;
            }
        }
        return buff.toString();
    }

    private void passive() throws IOException {
        send("PASV");
        readCode(226, 227);
        int first = message.indexOf('(') + 1;
        int last = message.indexOf(')');
        String[] address = StringUtils.arraySplit(message.substring(first, last), ',', true);
        StringBuffer buff = new StringBuffer();
        for (int i = 0; i < 4; i++) {
            if (i > 0) {
                buff.append('.');
            }
            buff.append(address[i]);
        }
        String ip = buff.toString();
        InetAddress addr = InetAddress.getByName(ip);
        int port = (Integer.parseInt(address[4]) << 8) | Integer.parseInt(address[5]);
        socketData = NetUtils.createSocket(addr, port, false);
        inData = socketData.getInputStream();
        outData = socketData.getOutputStream();
    }

    /**
     * Rename a file (RNFR / RNTO).
     *
     * @param fromFileName the old file name
     * @param toFileName the new file name
     */
    void rename(String fromFileName, String toFileName) throws IOException {
        send("RNFR " + fromFileName);
        readCode(350);
        send("RNTO " + toFileName);
        readCode(250);
    }

    /**
     * Read a file.
     *
     * @param fileName the file name
     * @return the content, null if the file doesn't exist
     */
    public byte[] retrieve(String fileName) throws IOException {
        ByteArrayOutputStream buff = new ByteArrayOutputStream();
        retrieve(fileName, buff, 0);
        return buff.toByteArray();
    }

    /**
     * Read a file ([REST] RETR).
     *
     * @param fileName the file name
     * @param out the output stream
     * @param restartAt restart at the given position (0 if no restart is required).
     */
    void retrieve(String fileName, OutputStream out, long restartAt) throws IOException {
        passive();
        if (restartAt > 0) {
            send("REST " + restartAt);
            readCode(350);
        }
        send("RETR " + fileName);
        IOUtils.copyAndClose(inData, out);
        readCode(150, 226);
    }

    /**
     * Remove a directory (RMD).
     *
     * @param dir the directory to remove
     */
    public void removeDirectory(String dir) throws IOException {
        send("RMD " + dir);
        readCode(226, 250);
    }

    /**
     * Remove all files and directory in a directory, and then delete the
     * directory itself.
     *
     * @param dir the directory to remove
     */
    public void removeDirectoryRecursive(String dir) throws IOException {
        for (File f : listFiles(dir)) {
            if (f.isDirectory()) {
                removeDirectoryRecursive(dir + "/" + f.getName());
            } else {
                delete(dir + "/" + f.getName());
            }
        }
        removeDirectory(dir);
    }

    /**
     * Get the size of a file (SIZE).
     *
     * @param fileName the file name
     * @return the size
     */
    long size(String fileName) throws IOException {
        send("SIZE " + fileName);
        readCode(250);
        long size = Long.parseLong(message);
        return size;
    }

    /**
     * Store a file (STOR).
     *
     * @param fileName the file name
     * @param in the input stream
     */
    public void store(String fileName, InputStream in) throws IOException {
        passive();
        send("STOR " + fileName);
        readCode(150);
        IOUtils.copyAndClose(in, outData);
        readCode(226);
    }

    /**
     * Copy a local file or directory to the FTP server, recursively.
     *
     * @param file the file to copy
     */
    public void storeRecursive(File file) throws IOException {
        if (file.isDirectory()) {
            makeDirectory(file.getName());
            changeWorkingDirectory(file.getName());
            for (File f : file.listFiles()) {
                storeRecursive(f);
            }
            changeWorkingDirectory("..");
        } else {
            InputStream in = new FileInputStream(file);
            store(file.getName(), in);
        }
    }

    /**
     * Get the directory listing (NLST).
     *
     * @param dir the directory
     * @return the listing
     */
    public String nameList(String dir) throws IOException {
        passive();
        send("NLST " + dir);
        readCode(150);
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        IOUtils.copyAndClose(inData, out);
        readCode(226);
        byte[] data = out.toByteArray();
        return new String(data);
    }

    /**
     * Get the directory listing (LIST).
     *
     * @param dir the directory
     * @return the listing
     */
    public String list(String dir) throws IOException {
        passive();
        send("LIST " + dir);
        readCode(150);
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        IOUtils.copyAndClose(inData, out);
        readCode(226);
        byte[] data = out.toByteArray();
        return new String(data);
    }

    /**
     * A file on an FTP server.
     */
    static class FtpFile extends File {
        private static final long serialVersionUID = 1L;
        private final boolean dir;
        private final long length;
        FtpFile(String name, boolean dir, long length) {
            super(name);
            this.dir = dir;
            this.length = length;
        }
        public long length() {
            return length;
        }
        public boolean isFile() {
            return !dir;
        }
        public boolean isDirectory() {
            return dir;
        }
        public boolean exists() {
            return true;
        }
    }

    /**
     * Check if a file exists on the FTP server.
     *
     * @param dir the directory
     * @param name the directory or file name
     * @return true if it exists
     */
    public boolean exists(String dir, String name) throws IOException  {
        for (File f : listFiles(dir)) {
            if (f.getName().equals(name)) {
                return true;
            }
        }
        return false;
    }

    /**
     * List the files on the FTP server.
     *
     * @param dir the directory
     * @return the list of files
     */
    public File[] listFiles(String dir) throws IOException {
        String content = list(dir);
        String[] list = StringUtils.arraySplit(content.trim(), '\n', true);
        File[] files = new File[list.length];
        for (int i = 0; i < files.length; i++) {
            String s = list[i];
            while (true) {
                String s2 = StringUtils.replaceAll(s, "  ", " ");
                if (s2.equals(s)) {
                    break;
                }
                s = s2;
            }
            String[] tokens = StringUtils.arraySplit(s, ' ', true);
            boolean directory = tokens[0].charAt(0) == 'd';
            long length = Long.parseLong(tokens[4]);
            String name = tokens[8];
            File f = new FtpFile(name, directory, length);
            files[i] = f;
        }
        return files;
    }

}
