/**
 * 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.geronimo.javamail.store.pop3.connection;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.StringTokenizer;

import javax.mail.MessagingException;
import javax.mail.internet.InternetHeaders;

import org.apache.geronimo.javamail.authentication.AuthenticatorFactory;
import org.apache.geronimo.javamail.authentication.ClientAuthenticator;
import org.apache.geronimo.javamail.store.imap.connection.IMAPResponseStream;
import org.apache.geronimo.javamail.store.pop3.POP3Constants;
import org.apache.geronimo.javamail.util.CommandFailedException;
import org.apache.geronimo.javamail.util.InvalidCommandException;
import org.apache.geronimo.javamail.util.MIMEInputReader;
import org.apache.geronimo.javamail.util.MailConnection;
import org.apache.geronimo.javamail.util.ProtocolProperties;
import org.apache.geronimo.mail.util.Base64;
import org.apache.geronimo.mail.util.Hex;

/**
 * Simple implementation of POP3 transport.
 *
 * @version $Rev$ $Date$
 */
public class POP3Connection extends MailConnection implements POP3Constants {

    static final protected String MAIL_APOP_ENABLED = "apop.enable";
    static final protected String MAIL_AUTH_ENABLED = "auth.enable";
    static final protected String MAIL_RESET_QUIT = "rsetbeforequit";
    static final protected String MAIL_DISABLE_TOP = "disabletop";
    //static final protected String MAIL_FORGET_TOP = "forgettopheaders"; //TODO forgettopheaders

    // the initial greeting string, which might be required for APOP authentication.
    protected String greeting;
    // is use of the AUTH command enabled
    protected boolean authEnabled;
    // is use of APOP command enabled
    protected boolean apopEnabled;
    // input reader wrapped around the socket input stream
    protected BufferedReader reader;
    // output writer wrapped around the socket output stream.
    protected PrintWriter writer;
    // this connection was closed unexpectedly
    protected boolean closed;
    // indicates whether this connection is currently logged in.  Once
    // we send a QUIT, we're finished.
    protected boolean loggedIn;
    // indicates whether we need to avoid using the TOP command
    // when retrieving headers
    protected boolean topDisabled = false;
    // is TLS enabled on our part?
    protected boolean useTLS = false;
    // is TLS required on our part?
    protected boolean requireTLS = false;

    /**
     * Normal constructor for an POP3Connection() object.
     *
     * @param props  The protocol properties abstraction containing our
     *               property modifiers.
     */
    public POP3Connection(ProtocolProperties props) {
        super(props);

        // get our login properties flags
        authEnabled = props.getBooleanProperty(MAIL_AUTH_ENABLED, false);
        apopEnabled = props.getBooleanProperty(MAIL_APOP_ENABLED, false);
        topDisabled = props.getBooleanProperty(MAIL_DISABLE_TOP, false);
        // and also check for TLS enablement.
        useTLS = props.getBooleanProperty(MAIL_STARTTLS_ENABLE, false);
        // and also check if TLS is required.
        requireTLS = props.getBooleanProperty(MAIL_STARTTLS_REQUIRED, false);
       
    }


    /**
     * Connect to the server and do the initial handshaking.
     *
     * @exception MessagingException
     */
    public boolean protocolConnect(String host, int port, String authid, String realm, String username, String password) throws MessagingException {
        this.serverHost = host;
        this.serverPort = port;
        this.realm = realm;
        this.authid = authid;
        this.username = username;
        this.password = password;

        try {
            // create socket and connect to server.
            getConnection();
            // consume the welcome line
            getWelcome();
            
            // if we're not already using an SSL connection, and we have permission to issue STARTTLS or its even required
            // try to setup a SSL connection
            if (!sslConnection && (useTLS || requireTLS)) {
                
                    // tell the server of our intention to start a TLS session
                    POP3Response starttlsResponse = null;
                    try {
                        starttlsResponse = sendCommand("STLS");
                    } catch (CommandFailedException e) {
                       
                    }
                    
                    //if the server does not support TLS check if its required.
                    //If true then throw an error, if not establish a non SSL connection
                    if(requireTLS && (starttlsResponse == null || starttlsResponse.isError())) {
                        throw new MessagingException("Server doesn't support required transport level security");
                    } else if(starttlsResponse != null && starttlsResponse.getStatus() == POP3Response.OK) {
                     // The connection is then handled by the superclass level.
                        getConnectedTLSSocket();
                    } else {
                        if (debug) {
                            debugOut("STARTTLS is enabled but not required and server does not support it. So we establish a connection without transport level security");
                        }
                    }
            }
            
            getConnection();
            
            // go login with the server
            if (login())
            {
                loggedIn = true;
                return true;
            }
            return false;
        } catch (IOException e) {
            if (debug) {
                debugOut("I/O exception establishing connection", e);
            }
            throw new MessagingException("Connection error", e);
        }
    }


    /**
     * Create a transport connection object and connect it to the
     * target server.
     *
     * @exception MessagingException
     */
    protected void getConnection() throws MessagingException
    {
        try {
            // do all of the non-protocol specific set up.  This will get our socket established
            // and ready use.
            super.getConnection();
        } catch (IOException e) {
            throw new MessagingException("Unable to obtain a connection to the POP3 server", e);
        }

        // The POP3 protocol is inherently a string-based protocol, so we get
        // string readers/writers for the connection streams.  Note that we explicitly
        // set the encoding to ensure that an inappropriate native encoding is not picked up.
        try {
            reader = new BufferedReader(new InputStreamReader(inputStream, "ISO8859-1"));
            writer = new PrintWriter(new OutputStreamWriter(new BufferedOutputStream(outputStream), "ISO8859-1"));
        } catch (UnsupportedEncodingException e) {
        }
    }

    protected void getWelcome() throws IOException {
        // just read the line and consume it.  If debug is
        // enabled, there I/O stream will be traced
        greeting = reader.readLine();
    }

    public String toString() {
        return "POP3Connection host: " + serverHost + " port: " + serverPort;
    }


    /**
     * Close the connection.  On completion, we'll be disconnected from
     * the server and unable to send more data.
     *
     * @exception MessagingException
     */
    public void close() throws MessagingException {
        // if we're already closed, get outta here.
        if (socket == null) {
            return;
        }
        try {
            // say goodbye
            logout();
        } finally {
            // and close up the connection.  We do this in a finally block to make sure the connection
            // is shut down even if quit gets an error.
            closeServerConnection();
            // get rid of our response processor too.
            reader = null;
            writer = null;
        }
    }


    /**
     * Tag this connection as having been closed by the
     * server.  This will not be returned to the
     * connection pool.
     */
    public void setClosed() {
        closed = true;
    }

    /**
     * Test if the connection has been forcibly closed.
     *
     * @return True if the server disconnected the connection.
     */
    public boolean isClosed() {
        return closed;
    }

    protected POP3Response sendCommand(String cmd) throws MessagingException {
        return sendCommand(cmd, false);
    }

    protected POP3Response sendMultiLineCommand(String cmd) throws MessagingException {
        return sendCommand(cmd, true);
    }

    protected synchronized POP3Response sendCommand(String cmd, boolean multiLine) throws MessagingException {
        if (socket.isConnected()) {
            {
                // NOTE:  We don't use println() because it uses the platform concept of a newline rather
                // than using CRLF, which is required by the POP3 protocol.
                writer.write(cmd);
                writer.write("\r\n");
                writer.flush();

                POP3Response response = buildResponse(multiLine);
                if (response.isError()) {
                    throw new CommandFailedException("Error issuing POP3 command: " + cmd);
                }
                return response;
            }
        }
        throw new MessagingException("Connection to Mail Server is lost, connection " + this.toString());
    }

    /**
     * Build a POP3Response item from the response stream.
     *
     * @param isMultiLineResponse
     *               If true, this command is expecting multiple lines back from the server.
     *
     * @return A POP3Response item with all of the command response data.
     * @exception MessagingException
     */
    protected POP3Response buildResponse(boolean isMultiLineResponse) throws MessagingException {
        int status = ERR;
        byte[] data = null;

        String line;
        //MIMEInputReader source = new MIMEInputReader(reader); //TODO unused

        try {
            line = reader.readLine();
        } catch (IOException e) {
            throw new MessagingException("Error in receving response");
        }

        if (line == null || line.trim().equals("")) {
            throw new MessagingException("Empty Response");
        }

        if (line.startsWith("+OK")) {
            status = OK;
            line = removeStatusField(line);
            if (isMultiLineResponse) {
                data = getMultiLineResponse();
            }
        } else if (line.startsWith("-ERR")) {
            status = ERR;
            line = removeStatusField(line);
        }else if (line.startsWith("+")) {
        	status = CHALLENGE;
        	line = removeStatusField(line);
        	if (isMultiLineResponse) {
        		data = getMultiLineResponse();
        	}
        } else {
            throw new MessagingException("Unexpected response: " + line);
        }
        return new POP3Response(status, line, data);
    }

    private static String removeStatusField(String line) {
        return line.substring(line.indexOf(SPACE) + 1);
    }

    /**
     * This could be a multiline response
     */
    private byte[] getMultiLineResponse() throws MessagingException {

        MIMEInputReader source = new MIMEInputReader(reader);

        ByteArrayOutputStream out = new ByteArrayOutputStream();

        // it's more efficient to do this a buffer at a time.
        // the MIMEInputReader takes care of the byte-stuffing and
        // ".\r\n" input terminator for us.
        try {
            OutputStreamWriter outWriter = new OutputStreamWriter(out, "ISO8859-1");
            char buffer[] = new char[500];
            try {
                int charsRead = -1;
                while ((charsRead = source.read(buffer)) >= 0) {
                    outWriter.write(buffer, 0, charsRead);
                }
                outWriter.flush();
            } catch (IOException e) {
                throw new MessagingException("Error processing a multi-line response", e);
            }
        } catch (UnsupportedEncodingException e) {
        }
        return out.toByteArray();
    }


    /**
     * Retrieve the raw message content from the POP3
     * server.  This is all of the message data, including
     * the header.
     *
     * @param sequenceNumber
     *               The message sequence number.
     *
     * @return A byte array containing all of the message data.
     * @exception MessagingException
     */
    public byte[] retrieveMessageData(int sequenceNumber) throws MessagingException {
        POP3Response msgResponse = sendMultiLineCommand("RETR " + sequenceNumber);
        // we want the data directly in this case.
        return msgResponse.getData();
    }

    /**
     * Retrieve the message header information for a given
     * message, returned as an input stream suitable
     * for loading the message data.
     *
     * @param sequenceNumber
     *               The server sequence number for the message.
     *
     * @return An inputstream that can be used to read the message
     *         data.
     * @exception MessagingException
     */
    public ByteArrayInputStream retrieveMessageHeaders(int sequenceNumber) throws MessagingException {
        POP3Response msgResponse;

        // some POP3 servers don't correctly implement TOP, so this can be disabled.  If
        // we can't use TOP, then use RETR and retrieve everything.  We can just hand back
        // the stream, as the header loading routine will stop at the first
        // null line.
        if (topDisabled) {
            msgResponse = sendMultiLineCommand("RETR " + sequenceNumber);
        }
        else {
            msgResponse = sendMultiLineCommand("TOP " + sequenceNumber + " 0");
        }

        // just load the returned message data as a set of headers
        return msgResponse.getContentStream();
    }

    /**
     * Retrieve the total message size from the mail
     * server.  This is the size of the headers plus
     * the size of the message content.
     *
     * @param sequenceNumber
     *               The message sequence number.
     *
     * @return The full size of the message.
     * @exception MessagingException
     */
    public int retrieveMessageSize(int sequenceNumber) throws MessagingException {
        POP3Response msgResponse = sendCommand("LIST " + sequenceNumber);
        // Convert this into the parsed response type we need.
        POP3ListResponse list = new POP3ListResponse(msgResponse);
        // this returns the total message size
        return list.getSize();
    }

    /**
     * Retrieve the mail drop status information.
     *
     * @return An object representing the returned mail drop status.
     * @exception MessagingException
     */
    public POP3StatusResponse retrieveMailboxStatus() throws MessagingException {
        // issue the STAT command and return this into a status response
        return new POP3StatusResponse(sendCommand("STAT"));
    }


    /**
     * Retrieve the UID for an individual message.
     *
     * @param sequenceNumber
     *               The target message sequence number.
     *
     * @return The string UID maintained by the server.
     * @exception MessagingException
     */
    public String retrieveMessageUid(int sequenceNumber) throws MessagingException {
        POP3Response msgResponse = sendCommand("UIDL " + sequenceNumber);

        String message = msgResponse.getFirstLine();
        // the UID is everything after the blank separating the message number and the UID.
        // there's not supposed to be anything else on the message, but trim it of whitespace
        // just to be on the safe side.
        return message.substring(message.indexOf(' ') + 1).trim();
    }


    /**
     * Delete a single message from the mail server.
     *
     * @param sequenceNumber
     *               The sequence number of the message to delete.
     *
     * @exception MessagingException
     */
    public void deleteMessage(int sequenceNumber) throws MessagingException {
        // just issue the command...we ignore the command response
        sendCommand("DELE " + sequenceNumber);
    }

    /**
     * Logout from the mail server.  This sends a QUIT
     * command, which will likely sever the mail connection.
     *
     * @exception MessagingException
     */
    public void logout() throws MessagingException {
        // we may have already sent the QUIT command
        if (!loggedIn) {
            return;
        }
        // just issue the command...we ignore the command response
        sendCommand("QUIT");
        loggedIn = false;
    }

    /**
     * Perform a reset on the mail server.
     *
     * @exception MessagingException
     */
    public void reset() throws MessagingException {
        // some mail servers mark retrieved messages for deletion
        // automatically.  This will reset the read flags before
        // we go through normal cleanup.
        if (props.getBooleanProperty(MAIL_RESET_QUIT, false)) {
            // just send an RSET command first
            sendCommand("RSET");
        }
    }

    /**
     * Ping the mail server to see if we still have an active connection.
     *
     * @exception MessagingException thrown if we do not have an active connection.
     */
    public void pingServer() throws MessagingException {
        // just issue the command...we ignore the command response
        sendCommand("NOOP");
    }

    /**
     * Login to the mail server, using whichever method is
     * configured.  This will try multiple methods, if allowed,
     * in decreasing levels of security.
     *
     * @return true if the login was successful.
     * @exception MessagingException
     */
    public synchronized boolean login() throws MessagingException {
        // permitted to use the AUTH command?
        if (authEnabled) {
            try {
                // go do the SASL thing
                return processSaslAuthentication();
            } catch (MessagingException e) {
                // Any error here means fall back to the next mechanism
            }
        }

        if (apopEnabled) {
            try {
                // go do the SASL thing
                return processAPOPAuthentication();
            } catch (MessagingException e) {
                // Any error here means fall back to the next mechanism
            }
        }

        try {
            // do the tried and true login processing.
            return processLogin();
        } catch (MessagingException e) {
        }
        // everything failed...can't get in
        return false;
    }


    /**
     * Process a basic LOGIN operation, using the
     * plain test USER/PASS command combo.
     *
     * @return true if we logged successfully.
     * @exception MessagingException
     */
    public boolean processLogin() throws MessagingException {
        // start by sending the USER command, followed by
        // the PASS command
        sendCommand("USER " + username);
        sendCommand("PASS " + password);
        return true;       // we're in
    }

    /**
     * Process logging in using the APOP command.  Only
     * works on servers that give a timestamp value
     * in the welcome response.
     *
     * @return true if the login was accepted.
     * @exception MessagingException
     */
    public boolean processAPOPAuthentication() throws MessagingException {
        int timeStart = greeting.indexOf('<');
        // if we didn't get an APOP challenge on the greeting, throw an exception
        // the main login processor will swallow that and fall back to the next
        // mechanism
        if (timeStart == -1) {
            throw new MessagingException("POP3 Server does not support APOP");
        }
        int timeEnd = greeting.indexOf('>');
        String timeStamp = greeting.substring(timeStart, timeEnd + 1);

        // we create the digest password using the timestamp value sent to use
        // concatenated with the password.
        String digestPassword = timeStamp + password;

        byte[] digest;

        try {
            // create a digest value from the password.
            MessageDigest md = MessageDigest.getInstance("MD5");
            digest = md.digest(digestPassword.getBytes("iso-8859-1"));
        } catch (NoSuchAlgorithmException e) {
            // this shouldn't happen, but if it does, we'll just try a plain
            // login.
            throw new MessagingException("Unable to create MD5 digest", e);
        } catch (UnsupportedEncodingException e) {
            // this shouldn't happen, but if it does, we'll just try a plain
            // login.
            throw new MessagingException("Unable to create MD5 digest", e);
        }
        // this will throw an exception if it gives an error failure
        sendCommand("APOP " + username + " " + new String(Hex.encode(digest)));
        // no exception, we must have passed
        return true;
    }


    /**
     * Process SASL-type authentication.
     *
     * @return Returns true if the server support a SASL authentication mechanism and
     *         accepted reponse challenges.
     * @exception MessagingException
     */
    protected boolean processSaslAuthentication() throws MessagingException {
        // if unable to get an appropriate authenticator, just fail it.
        ClientAuthenticator authenticator = getSaslAuthenticator();
        if (authenticator == null) {
            throw new MessagingException("Unable to obtain SASL authenticator");
        }

        // go process the login.
        return processLogin(authenticator);
    }

    /**
     * Attempt to retrieve a SASL authenticator for this
     * protocol.
     *
     * @return A SASL authenticator, or null if a suitable one
     *         was not located.
     */
    protected ClientAuthenticator getSaslAuthenticator() {
        return AuthenticatorFactory.getAuthenticator(props, selectSaslMechanisms(), serverHost, username, password, authid, realm);
    }


    /**
     * Process a login using the provided authenticator object.
     *
     * NB:  This method is synchronized because we have a multi-step process going on
     * here.  No other commands should be sent to the server until we complete.
     *
     * @return Returns true if the server support a SASL authentication mechanism and
     * accepted reponse challenges.
     * @exception MessagingException
     */
    protected synchronized boolean processLogin(ClientAuthenticator authenticator) throws MessagingException {
        if (debug) {
            debugOut("Authenticating for user: " + username + " using " + authenticator.getMechanismName());
        }

        POP3Response response = sendCommand("AUTH " + authenticator.getMechanismName());

        // now process the challenge sequence.  We get a continuation response back for each stage of the
        // authentication, and finally an OK when everything passes muster.
        while (true) {
            // this should be a continuation reply, if things are still good.
            if (response.isChallenge()) {
                // we're passed back a challenge value, Base64 encoded.
                byte[] challenge = response.decodeChallengeResponse();

                try {
                    String responseString = new String(Base64.encode(authenticator.evaluateChallenge(challenge)), "US-ASCII");

                    // have the authenticator evaluate and send back the encoded response.
                    response = sendCommand(responseString);
                } catch (UnsupportedEncodingException ex) {
                }
            }
            else {
                // there are only two choices here, OK or a continuation.  OK means
                // we've passed muster and are in.
                return true;
            }
        }
    }


    /**
     * Merge the configured SASL mechanisms with the capabilities that the
     * server has indicated it supports, returning a merged list that can
     * be used for selecting a mechanism.
     *
     * @return A List representing the intersection of the configured list and the
     *         capabilities list.
     */
    protected List selectSaslMechanisms() {
        // just return the set that have been explicity permitted
        return getSaslMechanisms();
    }
}