package com.juick.xmpp.s2s;

import com.juick.xmpp.utils.XmlUtils;

import java.io.EOFException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.Channels;
import java.nio.channels.CompletionHandler;
import java.util.logging.Level;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

/**
 *
 * @author ugnich
 */
public class ConnectionOut extends Connection {

    public boolean streamReady = false;
    public String to;
    String checkSID = null;
    String dbKey = null;

    public ConnectionOut(String hostname) {
        super();
        to = hostname;
    }

    public ConnectionOut(String hostname, String checkSID, String dbKey) {
        super();
        to = hostname;
        this.checkSID = checkSID;
        this.dbKey = dbKey;
    }

    public void parseStream() {
        LOGGER.info("STREAM TO " + to + " START");

        try {
            HostnamePort addr = DNSQueries.getServerAddress(to);
            socket = AsynchronousSocketChannel.open();
            socket.connect(new InetSocketAddress(addr.hostname, addr.port), socket, new CompletionHandler<Void, AsynchronousSocketChannel>() {
                @Override
                public void completed(Void result, AsynchronousSocketChannel attachment) {
                    try {
                        parser.setInput(new InputStreamReader(Channels.newInputStream(socket)));

                        writer = new OutputStreamWriter(Channels.newOutputStream(socket));

                        sendStanza("<?xml version='1.0'?><stream:stream xmlns='jabber:server' " +
                                "xmlns:stream='http://etherx.jabber.org/streams' xmlns:db='jabber:server:dialback' from='" +
                                XMPPComponent.HOSTNAME + "' to='" + to + "' version='1.0'>");

                        parser.next(); // stream:stream
                        streamID = parser.getAttributeValue(null, "id");
                        if (streamID == null || streamID.isEmpty()) {
                            throw new Exception("STREAM TO " + to + " INVALID FIRST PACKET");
                        }

                        LOGGER.info("STREAM TO " + to + " " + streamID + " OPEN");
                        XMPPComponent.addConnectionOut(ConnectionOut.this);

                        if (checkSID != null) {
                            sendDialbackVerify(checkSID, dbKey);
                        }

                        sendStanza("<db:result from='" + XMPPComponent.HOSTNAME + "' to='" + to + "'>" + generateDialbackKey(to, XMPPComponent.HOSTNAME, streamID) + "</db:result>");

                        while (parser.next() != XmlPullParser.END_DOCUMENT) {
                            if (parser.getEventType() != XmlPullParser.START_TAG) {
                                continue;
                            }
                            logParser();

                            String tag = parser.getName();
                            if (tag.equals("db:result")) {
                                String type = parser.getAttributeValue(null, "type");
                                if (type != null && type.equals("valid")) {
                                    streamReady = true;
                                    LOGGER.info("STREAM TO " + to + " " + streamID + " READY");

                                    String cache = XMPPComponent.getFromCache(to);
                                    if (cache != null) {
                                        LOGGER.info("STREAM TO " + to + " " + streamID + " SENDING CACHE");
                                        sendStanza(cache);
                                    }

                                } else {
                                    LOGGER.info("STREAM TO " + to + " " + streamID + " DIALBACK FAIL");
                                }
                                XmlUtils.skip(parser);
                            } else if (tag.equals("db:verify")) {
                                String from = parser.getAttributeValue(null, "from");
                                String type = parser.getAttributeValue(null, "type");
                                String sid = parser.getAttributeValue(null, "id");
                                if (from != null && from.equals(to) && sid != null && !sid.isEmpty() && type != null) {
                                    ConnectionIn c = XMPPComponent.getConnectionIn(sid);
                                    if (c != null) {
                                        c.sendDialbackResult(from, type);
                                    }
                                }
                                XmlUtils.skip(parser);
                            } else {
                                LOGGER.info("STREAM TO " + to + " " + streamID + ": " + XmlUtils.parseToString(parser, true));
                            }
                        }

                        LOGGER.warning("STREAM TO " + to + " " + streamID + " FINISHED");
                        XMPPComponent.removeConnectionOut(ConnectionOut.this);
                        closeConnection();
                    } catch (EOFException eofex) {
                        LOGGER.info(String.format("STREAM %s %s CLOSED (dirty)", to, streamID));
                        XMPPComponent.removeConnectionOut(ConnectionOut.this);
                        closeConnection();
                    } catch (Exception e) {
                        LOGGER.log(Level.SEVERE, "s2s out exception", e);
                        XMPPComponent.removeConnectionOut(ConnectionOut.this);
                        closeConnection();
                    }
                }

                @Override
                public void failed(Throwable exc, AsynchronousSocketChannel attachment) {
                    LOGGER.log(Level.WARNING, "s2s out failed", exc);
                    XMPPComponent.removeConnectionOut(ConnectionOut.this);
                    closeConnection();
                }
            });
        } catch (Exception e) {
            LOGGER.warning(e.toString());
            XMPPComponent.removeConnectionOut(this);
            closeConnection();
        }
    }

    public void sendDialbackVerify(String sid, String key) {
        try {
            sendStanza("<db:verify from='" + XMPPComponent.HOSTNAME + "' to='" + to + "' id='" + sid + "'>" + key + "</db:verify>");
        } catch (IOException e) {
            LOGGER.log(Level.WARNING, "STREAM TO " + to + " " + streamID + " ERROR", e);
        }
    }
}