package ca.uhn.hl7v2.hoh.raw.client;

import static ca.uhn.hl7v2.hoh.util.StringUtils.isBlank;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.MalformedURLException;
import java.net.Socket;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.charset.Charset;

import ca.uhn.hl7v2.hoh.api.DecodeException;
import ca.uhn.hl7v2.hoh.api.EncodeException;
import ca.uhn.hl7v2.hoh.api.IAuthorizationClientCallback;
import ca.uhn.hl7v2.hoh.api.IClient;
import ca.uhn.hl7v2.hoh.api.IReceivable;
import ca.uhn.hl7v2.hoh.api.ISendable;
import ca.uhn.hl7v2.hoh.api.MessageMetadataKeys;
import ca.uhn.hl7v2.hoh.encoder.Hl7OverHttpRequestEncoder;
import ca.uhn.hl7v2.hoh.encoder.Hl7OverHttpResponseDecoder;
import ca.uhn.hl7v2.hoh.encoder.NoMessageReceivedException;
import ca.uhn.hl7v2.hoh.raw.api.RawReceivable;
import ca.uhn.hl7v2.hoh.sign.ISigner;
import ca.uhn.hl7v2.hoh.sign.SignatureVerificationException;
import ca.uhn.hl7v2.hoh.sockets.ISocketFactory;
import ca.uhn.hl7v2.hoh.sockets.StandardSocketFactory;
import ca.uhn.hl7v2.hoh.sockets.TlsSocketFactory;

public abstract class AbstractRawClient implements IClient {

        /**
         * The default charset encoding (UTF-8)
         */
        public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

        /**
         * The default connection timeout in milliseconds: 10000
         */
        public static final int DEFAULT_CONNECTION_TIMEOUT = 10000;

        /**
         * The default number of milliseconds to wait before timing out waiting for
         * a response: 60000
         */
        public static final int DEFAULT_RESPONSE_TIMEOUT = 60000;

        private static final StandardSocketFactory DEFAULT_SOCKET_FACTORY = new StandardSocketFactory();

        private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(HohRawClientSimple.class);

        private IAuthorizationClientCallback myAuthorizationCallback;
        private Charset myCharset = DEFAULT_CHARSET;
        private int myConnectionTimeout = DEFAULT_CONNECTION_TIMEOUT;
        private String myHost;
        private BufferedInputStream myInputStream;
        private boolean myKeepAlive = true;
        private OutputStream myOutputStream;
        private String myPath;
        private int myPort;
        private long myResponseTimeout = DEFAULT_RESPONSE_TIMEOUT;
        private ISigner mySigner;
        private ISocketFactory mySocketFactory = DEFAULT_SOCKET_FACTORY;
        /**
         * Socket so_timeout value for newly created sockets
         */
        private int mySoTimeout = 5000;
        private URL myUrl;
        /**
         * Constructor
         */
        public AbstractRawClient() {
                // nothing
        }
        /**
         * Constructor
         * 
         * @param theHost
         *            The HOST (name/address). E.g. "192.168.1.1"
         * @param thePort
         *            The PORT. E.g. "8080"
         * @param thePath
         *            The path being requested (must either be blank or start with
         *            '/' and contain a path). E.g. "/Apps/Receiver.jsp"
         */
        public AbstractRawClient(String theHost, int thePort, String thePath) {
                setHost(theHost);
                setPort(thePort);
                setUriPath(thePath);
        }
        /**
         * Constructor
         * 
         * @param theUrl
         *            The URL to connect to. Note that if the URL refers to the
         *            "https" protocol, a {@link #setSocketFactory(ISocketFactory)
         *            SocketFactory} which uses TLS will be set. If custom
         *            certificates are used, a different factory may need to be
         *            provided manually.
         */
        public AbstractRawClient(URL theUrl) {
                setUrl(theUrl);
        }

        protected void closeSocket(Socket theSocket) {
                ourLog.debug("Closing socket");
                try {
                        theSocket.close();
                } catch (IOException e) {
                        ourLog.warn("Problem closing socket", e);
                }
        }

        protected Socket connect() throws IOException {
                ourLog.debug("Creating new connection to {}:{} for URI {}", new Object[] { myHost, myPort, myPath });

                Socket socket = mySocketFactory.createClientSocket();
                socket.connect(new InetSocketAddress(myHost, myPort), myConnectionTimeout);
                socket.setSoTimeout(mySoTimeout);
                socket.setKeepAlive(myKeepAlive);
                ourLog.trace("Connection established to {}:{}", myHost, myPort);
                myOutputStream = new BufferedOutputStream(socket.getOutputStream());
                myInputStream = new BufferedInputStream(socket.getInputStream());
                return socket;
        }

        private IReceivable<String> doSendAndReceiveInternal(ISendable<?> theMessageToSend, Socket socket) throws IOException, DecodeException, SignatureVerificationException, EncodeException {
                ourLog.trace("Entering doSendAndReceiveInternal()");
                
                Hl7OverHttpRequestEncoder enc = new Hl7OverHttpRequestEncoder();
                enc.setPath(myPath);
                enc.setHost(myHost);
                enc.setPort(myPort);
                enc.setCharset(myCharset);
                if (myAuthorizationCallback != null) {
                        enc.setUsername(myAuthorizationCallback.provideUsername(myPath));
                        enc.setPassword(myAuthorizationCallback.providePassword(myPath));
                }
                enc.setSigner(mySigner);
                enc.setDataProvider(theMessageToSend);

                ourLog.debug("Writing message to OutputStream");
                enc.encodeToOutputStream(myOutputStream);
                myOutputStream.flush();

                ourLog.debug("Reading response from OutputStream");

                RawReceivable response = null;
                long endTime = System.currentTimeMillis() + myResponseTimeout;
                do {
                        try {
                                Hl7OverHttpResponseDecoder d = new Hl7OverHttpResponseDecoder();
                                d.setSigner(mySigner);
                                d.setReadTimeout(myResponseTimeout);
                                d.readHeadersAndContentsFromInputStreamAndDecode(myInputStream);

                                response = new RawReceivable(d.getMessage());
                                InetSocketAddress remoteSocketAddress = (InetSocketAddress) socket.getRemoteSocketAddress();
                                String hostAddress = remoteSocketAddress.getAddress() != null ? remoteSocketAddress.getAddress().getHostAddress() : null;
                                response.addMetadata(MessageMetadataKeys.REMOTE_HOST_ADDRESS.name(), hostAddress);

                                if (d.isConnectionCloseHeaderPresent()) {
                                        ourLog.debug("Found Connection=close header, closing socket");
                                        closeSocket(socket);
                                }
                                
                        } catch (NoMessageReceivedException ex) {
                                ourLog.debug("No message received yet");
                        } catch (IOException e) {
                                throw new DecodeException("Failed to read response from remote host", e);
                        }
                } while (response == null && System.currentTimeMillis() < endTime);

                ourLog.trace("Leaving doSendAndReceiveInternal()");
                return response;
        }

        /*
         * (non-Javadoc)
         * 
         * @see ca.uhn.hl7v2.hoh.raw.client.IClient#getHost()
         */
        public String getHost() {
                return myHost;
        }

        /*
         * (non-Javadoc)
         * 
         * @see ca.uhn.hl7v2.hoh.raw.client.IClient#getPort()
         */
        public int getPort() {
                return myPort;
        }

        /*
         * (non-Javadoc)
         * 
         * @see ca.uhn.hl7v2.hoh.raw.client.IClient#getSocketFactory()
         */
        public ISocketFactory getSocketFactory() {
                return mySocketFactory;
        }

        public int getSoTimeout() {
                return mySoTimeout;
        }

        /*
         * (non-Javadoc)
         * 
         * @see ca.uhn.hl7v2.hoh.raw.client.IClient#getUri()
         */
        public String getUriPath() {
                return myPath;
        }

        /**
         * {@inheritDoc}
         */
        public URL getUrl() {
                return myUrl;
        }

        /**
         * {@inheritDoc}
         */
        public String getUrlString() {
                return getUrl().toExternalForm();
        }

        public boolean isKeepAlive() {
                return myKeepAlive;
        }

        boolean isSocketConnected(Socket socket) {
                return socket != null && !socket.isClosed() && !socket.isInputShutdown() && !socket.isOutputShutdown();
        }

        /**
         * Subclasses must override to provide a connected socket
         */
        protected abstract Socket provideSocket() throws IOException;

        /**
         * Returns the socket provided by {@link #provideSocket()}. This method will
         * always be called after the request is finished.
         */
        protected abstract void returnSocket(Socket theSocket);

        /**
         * Sends a message, waits for the response, and then returns the response if
         * any
         * 
         * @param theMessageToSend
         *            The message to send
         * @return The returned message, as well as associated metadata
         * @throws DecodeException
         *             If a problem occurs (read error, socket disconnect, etc.)
         *             during communication, or the response is invalid in some way.
         *             Note that IO errors in trying to connect to the remote host
         *             or sending the message are thrown directly (i.e. as
         *             {@link IOException}), but IO errors in reading the response
         *             are thrown as DecodeException
         * @throws IOException
         *             If the client is unable to connect to the remote host
         * @throws EncodeException
         *             If a failure occurs while encoding the message into a
         *             sendable HTTP request
         */
        public synchronized IReceivable<String> sendAndReceive(ISendable<?> theMessageToSend) throws DecodeException, IOException, EncodeException {

                Socket socket = provideSocket();
                try {
                        return doSendAndReceiveInternal(theMessageToSend, socket);
                } catch (DecodeException e) {
                        ourLog.debug("Decode exception, going to close socket", e);
                        closeSocket(socket);
                        throw e;
                } catch (IOException e) {
                        ourLog.debug("Caught IOException, going to close socket", e);
                        closeSocket(socket);
                        throw e;
                } catch (SignatureVerificationException e) {
                        ourLog.debug("Failed to verify message signature", e);
                        throw new DecodeException("Failed to verify message signature", e);
                } finally {
                        returnSocket(socket);
                }

        }

        /*
         * (non-Javadoc)
         * 
         * @see
         * ca.uhn.hl7v2.hoh.raw.client.IClient#setAuthorizationCallback(ca.uhn.hl7v2
         * .hoh.api.IAuthorizationClientCallback)
         */
        public void setAuthorizationCallback(IAuthorizationClientCallback theAuthorizationCallback) {
                myAuthorizationCallback = theAuthorizationCallback;
        }

        /**
         * {@inheritDoc}
         */
        public void setCharset(Charset theCharset) {
                if (theCharset == null) {
                        throw new NullPointerException("Charset can not be null");
                }
                myCharset = theCharset;
        }

        /**
         * {@inheritDoc}
         */
        public void setHost(String theHost) {
                myHost = theHost;
                if (isBlank(theHost)) {
                        throw new IllegalArgumentException("Host can not be blank/null");
                }
        }

        /**
         * {@inheritDoc}
         */
        public void setKeepAlive(boolean theKeepAlive) {
                myKeepAlive = theKeepAlive;
        }

        /**
         * {@inheritDoc}
         */
        public void setPort(int thePort) {
                myPort = thePort;
                if (thePort <= 0) {
                        throw new IllegalArgumentException("Port must be a positive integer");
                }
        }


        /**
         * {@inheritDoc}
         */
        public void setResponseTimeout(long theResponseTimeout) {
                if (theResponseTimeout <= 0) {
                        throw new IllegalArgumentException("Timeout can not be <= 0");
                }
                myResponseTimeout = theResponseTimeout;
        }

        /**
         * {@inheritDoc}
         */
        public void setSigner(ISigner theSigner) {
                mySigner = theSigner;
        }

        /**
         * {@inheritDoc}
         */
        public void setSocketFactory(ISocketFactory theSocketFactory) {
                if (theSocketFactory == null) {
                        throw new NullPointerException("Socket factory can not be null");
                }
                mySocketFactory = theSocketFactory;
        }

        /**
         * {@inheritDoc}
         */
        public void setSoTimeout(int theSoTimeout) {
                mySoTimeout = theSoTimeout;
        }

        /**
         * {@inheritDoc}
         */
        public void setUriPath(String thePath) {
                myPath = thePath;

                if (isBlank(thePath)) {
                        myPath = "/";
                }
                if (!thePath.startsWith("/")) {
                        throw new IllegalArgumentException("Invalid URI (must start with '/'): " + thePath);
                } else if (thePath.contains(" ")) {
                        throw new IllegalArgumentException("Invalid URI: " + thePath);
                }
                
                // Validate for syntax
                try {
                        new URI("http://localhost" + thePath);
                } catch (URISyntaxException e) {
                        throw new IllegalArgumentException("Invalid URI: " + thePath);
                }
                
        }

        /**
         * {@inheritDoc}
         */
        public void setUrl(URL theUrl) {
                setHost(extractHost(theUrl));
                setPort(extractPort(theUrl));
                setUriPath(extractUri(theUrl));

                myUrl = theUrl;

                if (getSocketFactory() == DEFAULT_SOCKET_FACTORY && theUrl.getProtocol().toLowerCase().equals("https")) {
                        setSocketFactory(new TlsSocketFactory());
                }
        }

        /**
         * {@inheritDoc}
         */
        public void setUrlString(String theString) {
                try {
                        URL url = new URL(theString);
                        setUrl(url);
                } catch (MalformedURLException e) {
                        throw new IllegalArgumentException("URL is not valid. Must be in the form http[s]:");
                }
                String protocol = myUrl.getProtocol().toLowerCase();
                if (!protocol.equals("http") && !protocol.equals("https")) {
                        throw new IllegalStateException("URL protocol must be http or https");
                }

        }

        private static String extractHost(URL theUrl) {
                return theUrl.getHost();
        }

        private static int extractPort(URL theUrl) {
                return theUrl.getPort() != -1 ? theUrl.getPort() : theUrl.getDefaultPort();
        }

        private static String extractUri(URL theUrl) {
                return theUrl.getPath();
        }
}