package com.server;

import java.io.*;
import java.math.BigInteger;
import java.net.InetSocketAddress;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Scanner;

import akka.actor.AbstractActor;
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.io.Tcp;
import akka.io.Tcp.CommandFailed;
import akka.io.Tcp.Connected;
import akka.io.Tcp.ConnectionClosed;
import akka.io.TcpMessage;
import akka.util.ByteString;
import org.jetbrains.annotations.NotNull;


public class Client extends AbstractActor {
    private boolean entered = false;

    static Props props(InetSocketAddress remote) {
        return Props.create(Client.class, remote);
    }

    // Подключаемся к серверу
    public Client(InetSocketAddress remote) {
        final ActorRef tcp = Tcp.get(getContext().getSystem()).manager();
        tcp.tell(TcpMessage.connect(remote), getSelf());
    }


    static class UserInformation {
        final String userName;
        final String password;
        final char group;
        final char register;

        UserInformation(String userName, String password, char group, char register) {
            this.userName = userName;
            this.password = password;
            this.group = group;
            this.register = register;
        }

        ByteString getInformation() {
            return ByteString.fromString(String.format("%s %s %s %s", userName, md5Custom(password), group, register));
        }

        @NotNull
        private static String md5Custom(String st) {
            byte[] digest = new byte[0];
            try {
                MessageDigest messageDigest = MessageDigest.getInstance("MD5");
                messageDigest.reset();
                messageDigest.update(st.getBytes());
                digest = messageDigest.digest();
            } catch (NoSuchAlgorithmException e) {
                // тут можно обработать ошибку
                // возникает она если в передаваемый алгоритм в getInstance(,,,) не существует
                e.printStackTrace();
            }

            BigInteger bigInt = new BigInteger(1, digest);
            StringBuilder md5Hex = new StringBuilder(bigInt.toString(16));

            while( md5Hex.length() < 32 ){
                md5Hex.insert(0, "0");
            }

            return md5Hex.toString();
        }
    }

    @Override
    public Receive createReceive() {
        return receiveBuilder()
                .match(CommandFailed.class, msg -> {
                    getContext().stop(getSelf());

                })
                .match(Connected.class, msg -> {
                    getSender().tell(TcpMessage.register(getSelf(), true, true), getSelf());
                    getContext().become(connected(getSender()));
                })
                .build();
    }

    private Receive connected(final ActorRef connection) {
       // System.out.println(connection);
        return receiveBuilder()
                .match(UserInformation.class, info -> {

                    connection.tell(TcpMessage.write(info.getInformation()),
                            getSelf());
                    entered = true;
                })
                .match(ByteString.class, msg -> {
                    connection.tell(TcpMessage.write(msg), getSelf());
                })
                .match(CommandFailed.class, msg -> {
                    System.out.println("Command Failed");
                })
                .matchEquals("close",msg -> {
                    connection.tell(TcpMessage.close(), getSelf());
                })
                .match(TcpMessage.class, msg -> {
                    getSender().tell(msg, getSelf());
                })
                .match(ConnectionClosed.class, msg -> {
                    getContext().stop(getSelf());
                    System.out.println("Server Closed");
                })
                .match(Tcp.Received.class, msg -> {
                    byte[] byteArray = msg.data().toArray();

                    ServerInformation message;
                    // Дессериализация класса
                    try {
                        ObjectInputStream objectInputStream = new ObjectInputStream(
                                new ByteArrayInputStream(byteArray));

                        message = (ServerInformation) objectInputStream.readObject();
                        objectInputStream.close();
                    } catch (ClassCastException ex) {
                        System.out.println("Wrong message from server");
                        return;
                    } catch (IOException ex) {
                        System.out.println("Wrong class");
                        return;
                    }

                    System.out.println(message.getServerMessage());
                    if(message.isEntered()) return;

                    if(!entered && message.isWrongName()) {
                        System.out.println("This nickname already exists");
                        return;
                    }
                    entered = true;
                    System.out.println("You are logged in to your account");



                })
                .build();
    }



}
// Класс, для отправки информации о клиенте
class MessageFromClient extends Message {
    Coordinates from;
    Coordinates to;

    public MessageFromClient(Coordinates from, Coordinates to, double price, int minutes) {
        this.from = from;
        this.to = to;
        this.price = price;
        this.minutes = minutes;
    }

    double price;
    int minutes;

    static public MessageFromClient createMessage() {
        Scanner in = new Scanner(System.in);

        System.out.println("Enter your location");
        Coordinates from = new MessageFromClient.Coordinates(in.nextDouble(), in.nextDouble());

        System.out.println("Enter the place of arrival");
        Coordinates to = new MessageFromClient.Coordinates(in.nextDouble(), in.nextDouble());

        System.out.println("Enter your price");
        double price = in.nextDouble();

        System.out.println("Enter your waiting time");
        int waitingTime = in.nextInt();

        return new MessageFromClient(from, to, price, waitingTime);
    }

    @Override
    public String toString() {
        return "MessageFromClient{" +
                "from=" + from +
                ", to=" + to +
                ", price=" + price +
                ", minutes=" + minutes +
                '}';
    }
}

class ClientMain {
    final static ActorSystem system = ActorSystem.create("System");
    final static ActorRef client = system.actorOf(Client.props(InetSocketAddress.createUnresolved(
            "localhost",8080)), "Client");


    public static void main(String[] args) throws IOException, InterruptedException {
        Thread.sleep(1000);
        client.tell(new Client.UserInformation("Anton", "123", 'd', 'n'), ActorRef.noSender());

        ByteArrayOutputStream byteArrayOutputStream =
                new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream =
                new ObjectOutputStream(byteArrayOutputStream);

        objectOutputStream.writeObject(MessageFromClient.createMessage());
        objectOutputStream.flush();

        client.tell(ByteString.fromArray(byteArrayOutputStream.toByteArray()),
                ActorRef.noSender());

    }

}

abstract class Message implements Serializable {
    static class Coordinates implements Serializable {
        Coordinates(double x, double y) {
            this.x = x;
            this.y = y;
        }


        double x;
        double y;

        @Override
        public String toString() {
            return "Coordinates{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }

}

class ServerInformation implements Serializable {
    ServerInformation(boolean entered, String serverMessage, boolean wrongName) {
        this.entered = entered;
        this.serverMessage = serverMessage;
        this.wrongName = wrongName;
    }

    private boolean entered;
    private String serverMessage;
    private boolean wrongName;

    public void setEntered(boolean entered) {
        this.entered = entered;
    }

    boolean isEntered() {
        return entered;
    }

    String getServerMessage() {
        return serverMessage;
    }


    public void setWrongName(boolean wrongName) {
        this.wrongName = wrongName;
    }

    boolean isWrongName() {
        return wrongName;
    }

    byte[] serializeSelf() throws IOException {
        ByteArrayOutputStream byteArrayOutputStream =
                new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream =
                new ObjectOutputStream(byteArrayOutputStream);

        objectOutputStream.writeObject(this);
        objectOutputStream.flush();

        return byteArrayOutputStream.toByteArray();
    }
}