package electrosphere.net.client;

import electrosphere.entity.types.creature.CreatureUtils;
import electrosphere.entity.Entity;
import electrosphere.entity.EntityUtils;
import electrosphere.main.Globals;
import electrosphere.main.Main;
import electrosphere.net.message.EntityMessage;
import electrosphere.net.message.NetworkMessage;
import electrosphere.net.message.PlayerMessage;
import electrosphere.net.raw.NetworkParser;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigInteger;
import java.net.Socket;
import java.net.SocketException;
import java.security.spec.RSAKeyGenParameterSpec;
import java.util.Properties;
import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Semaphore;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.crypto.stream.CryptoInputStream;
import org.apache.commons.crypto.stream.CryptoOutputStream;

/**
 *
 * @author amaterasu
 */
public class ClientNetworking implements Runnable{
    
    
    Socket socket;
//    CryptoInputStream inputStream;
//    CryptoOutputStream outputStream;
    InputStream inputStream;
    OutputStream outputStream;
    boolean initialized;
    NetworkParser parser;
    
    public ClientNetworking(String address, int port){
        try {
            this.socket = new Socket(address,port);
        } catch (IOException ex) {
            System.err.println("Failed to connect!");
            ex.printStackTrace();
            System.exit(1);
        }
    }
    
    
    
    @Override
    public void run(){
        initialized = false;
            //        final SecretKeySpec key = new SecretKeySpec(("1234567890123456").getBytes(),"AES");
//        final Properties properties = new Properties();
//        final RSAKeyGenParameterSpec spec = new RSAKeyGenParameterSpec(4096, BigInteger.probablePrime(4000, new Random()));
//        try {
//            inputStream = new CryptoInputStream("AES/ECB/PKCS5Padding",properties,socket.getInputStream(),key,spec);
//        } catch (IOException ex) {
//            ex.printStackTrace();
//            System.exit(1);
//        }
//        try {
//            outputStream = new CryptoOutputStream("AES/ECB/PKCS5Padding",properties,socket.getOutputStream(),key,spec);
//        } catch (IOException ex) {
//            ex.printStackTrace();
//            System.exit(1);
//        }
        try {
            inputStream = socket.getInputStream();
            outputStream = socket.getOutputStream();
            parser = new NetworkParser(inputStream,outputStream);
        } catch (IOException ex) {
            Logger.getLogger(ClientNetworking.class.getName()).log(Level.SEVERE, null, ex);
        }
        initialized = true;
        while(Main.isRunning()){
            //attempt poll incoming messages
            parser.readMessagesIn();
            //outgoing messages
            parser.pushMessagesOut();
        }
    }
    
    
    public void parseMessages(){
        if(initialized){
            while(parser.hasIncomingMessaage()){
                NetworkMessage message = parser.popIncomingMessage();
                System.out.println("New message " + message.getType());
                //do something
                handleMessage(message);
            }
        }
    }
    
    void handleMessage(NetworkMessage message){
        switch(message.getType()){
            case ENTITY_MESSAGE:
                handleEntityMessage((EntityMessage)message);
                break;
            case PLAYER_MESSAGE:
                handlePlayerMessage((PlayerMessage)message);
                break;
        }
    }
    
    void handleEntityMessage(EntityMessage message){
        System.out.println(message.getEntityMessageType());
        switch(message.getEntityMessageType()){
            case CREATE:
                System.out.println("Spawn ID " + message.getEntityType());
                Entity newlySpawnedEntity = CreatureUtils.spawnBasicCreature(message.getEntityType(), 0.005f, 0.025f);
                EntityUtils.getEntityScale(newlySpawnedEntity).set(0.005f);
                EntityUtils.getEntityPosition(newlySpawnedEntity).set(10 - 0.5f,Globals.terrainManager.getHeightAtPosition(10, 10),10 - 0.5f);
                EntityUtils.setEntityID(newlySpawnedEntity, message.getId());
                break;
            case DESTROY:
                break;
            case MOVE:
                //literally just adding this to scope so I can use `` Entity target; `` again
                if(message.getId() != -1){
                    Entity target = Globals.entityManager.getEntityFromId(message.getId());
                    EntityUtils.getEntityPosition(target).set(message.getX(),message.getY(),message.getZ());
                }
//                CreatureUtils.attachEntityMessageToMovementTree(Globals.entityManager.getEntityFromId(message.getId()),message);
                break;
            case SET_BEHAVIOR_TREE:
                break;
            case SET_PROPERTY:
                if(message.getPropertyType() == 0){
                    Entity target = Globals.entityManager.getEntityFromId(message.getId());
                    if(target != null){
                        CreatureUtils.setControllerPlayerId(target, message.getPropertyValue());
                        if(message.getPropertyValue() == Main.playerId){
                            Globals.playerCharacter = target;
                        }
                    }
                }
                break;
        }
    }
    
    void handlePlayerMessage(PlayerMessage message){
        switch(message.getPlayerMessageType()){
            case SET_PLAYER_ID:
                Main.playerId = message.getId();
                System.out.println("Player ID is " + Main.playerId);
                break;
        }
    }
    
    public void queueOutgoingMessage(NetworkMessage message){
        parser.addOutgoingMessage(message);
    }
    
}