package viktoriia.vihriian.todolist;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.Menu;
import android.view.MenuItem;

import com.simplexsolutionsinc.Utils.Log;
import com.sx_network.FailureRequestResult;
import com.sx_network.SXAccountsManager;
import com.sx_network.SuccessRequestResult;

import org.json.JSONObject;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import viktoriia.vihriian.todolist.tools.proto.Message;
import viktoriia.vihriian.todolist.tools.proto.MessageCommon;
import viktoriia.vihriian.todolist.tools.proto.MessageTypeOuterClass;
import viktoriia.vihriian.todolist.tools.proto.MessageWorkgroup;

public class MainActivity extends AppCompatActivity {
    public final String LOG = getClass().getName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        new Thread(new Runnable() {
            @Override
            public void run() {
//                        registerUser("vihriian_viktoriia@gmail.com", "kelguguza112");
                authorizeUser("to_improvis@mail.ru", "kelguguza112");
            }
        }).start();
    }

    private void authorizeUser(String login, String password) {
        SXAccountsManager account = SXAccountsManager.getInstance();
        account.init(getApplication());

        account.authorizeUser(login, password, new SuccessRequestResult() {
                    @Override
                    public void onSuccess(JSONObject response, String login, String password) {
                        final String session = response.optString("session");

                        new Thread(new Runnable() {
                            @Override
                            public void run() {
                                communicateWithServer(session);
                            }
                        }).start();

                        Log.d(LOG, "Authorization was successful!\n" + session);
                    }
                },
                new FailureRequestResult() {
                    @Override
                    public void onFailure(JSONObject response, String login, String password) {
                        Log.d(LOG, "Authorization failed!\n" + response.toString());
                    }
                });

    }

    private void registerUser(String login, String password) {
        SXAccountsManager account = SXAccountsManager.getInstance();
        account.init(getApplication());
        account.registerUser(login, password, new SuccessRequestResult() {
                    @Override
                    public void onSuccess(JSONObject response, String login, String password) {
                        Log.d(LOG, "Registration was successful!\n" + response.toString());
                    }
                },
                new FailureRequestResult() {
                    @Override
                    public void onFailure(JSONObject response, String login, String password) {
                        Log.d(LOG, "Registration failed!\n" + response.toString());
                    }
                });
    }

    private void communicateWithServer(String session) {

        TrustManager trustManager = new DefaultTrustManager();
        SSLContext sslContext = null;
        SSLSocket sslSocket = null;

        try {
            sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, new TrustManager[]{ trustManager }, null);
            sslSocket = (SSLSocket) sslContext.getSocketFactory()
                    .createSocket("rpc.v1.keepsolid.com", 443);

            Log.d(LOG, "Before handshake " + sslSocket.toString());
            sslSocket.startHandshake();
            Log.d(LOG, "After handshake " + sslSocket.toString());

            DataOutputStream dataOutputStream = new DataOutputStream(sslSocket.getOutputStream());
            DataInputStream dataInputStream = new DataInputStream(sslSocket.getInputStream());

//            send request
            MessageWorkgroup.WorkGroupsListRequest.Builder workGroupsListRequest =
                    MessageWorkgroup.WorkGroupsListRequest.newBuilder()
                            .setFilter(MessageCommon.Filter.ALL_ENTRIES)
                            .setSessionId(session);

            Message.Request request = Message.Request.newBuilder()
                    .setMessageType(MessageTypeOuterClass.MessageType.RPC_WORKGROUPS_LIST)
                    .setServiceType(1)
                    .setIsDebug(true)
                    .setWorkgroupsList(workGroupsListRequest)
                    .build();

            byte[] message = request.toByteArray();
            long sequenceNumber = 0;

            ByteBuffer bb = ByteBuffer.allocate(Long.SIZE / 8);
            bb.order(ByteOrder.LITTLE_ENDIAN);

            dataOutputStream.writeLong(sequenceNumber);

            bb.putLong(message.length);
            dataOutputStream.write(bb.array());
            dataOutputStream.write(message);
            dataOutputStream.flush();

//            get response
            sequenceNumber = dataInputStream.readLong();
            Log.d(LOG, "Sequence number: " + sequenceNumber);

            byte[] readBuffer = new byte[4];
            dataInputStream.read(readBuffer);

            int size = (readBuffer[0] & 0xFF) | (readBuffer[1] & 0xFF) << 8 | (readBuffer[2] &
                    0xFF) << 16 | (readBuffer[3] & 0xFF) << 24;

            dataInputStream.readInt();

            byte[] bufferProto = new byte[size];
            dataInputStream.read(bufferProto);
            Message.Response response = Message.Response.newBuilder()
                    .mergeFrom(bufferProto)
                    .build();

//            Log.d(LOG, "Response: \n" + response);
            for (MessageCommon.WorkGroupInfo info : response.getWorkgroupsList()
                    .getWorkgroupInfoListList()) {
                Log.d(LOG, "\n" + info);
            }
            dataOutputStream.close();
            dataInputStream.close();
            sslSocket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static class DefaultTrustManager implements X509TrustManager {

        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
        }

        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
        }

        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }
    }

    //Little Endian order
    public void writeInt(OutputStream os, int i) throws IOException {
        ByteBuffer bytes = ByteBuffer.allocate(4).putInt(i);
        bytes.order(ByteOrder.LITTLE_ENDIAN);
        os.write(bytes.array());
    }

    public static byte[] readPart(InputStream in, long offset, int length) throws Exception {
        byte[] data = new byte[length];
        in.skip(offset);
        in.read(data, 0, data.length);

        return data;
    }


    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu_main, menu);

        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        int id = item.getItemId();

        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}