using UnityEngine;
using System.Collections;
using System.Diagnostics;
using Photon;
using Assets.Scripts;

using System;
using System.Collections.Generic;

public class AIController : PunBehaviour, IControlledObject {
    public Transform target;
    NavMeshAgent agent;
    private bool targetSet;
    private Vector3 lastFramePos;
    public Stopwatch stunTimer;
    public Animator animator;
    public Rigidbody rigidbody;
    public bool serverPrepDone;
    public int maxStunTime;
    public Color normalColor;
    public FactionManager manager;
    public ServerManager serverManager;
    public TeamManager teamManager;
    public bool stunned;
    public int localPlayerNumber = 0;
    //public PlayerIndex playerIndex;
    public bool playerIndexSet;
    IExternalGamePad GamePad;
    public GroundCheck groundCheck;
    public float x = 0;
    public float y = 0;
    public bool jump;
    public string[] controllerPriority;
    public GameObject[] objectsToDisableOnStun;
    public GameObject[] objectsToEnableOnStun;
    public Vector3 startingPos;
    public float jumpForce;
    public bool colorWasSet;
    public Vector3 lastAgentPosition;
    public DateTime lastAgentPositionCheck;
    private bool agentHasBeenActivated;
    private Stopwatch decisionTimer;

    public bool Stunned {
        get {
            return stunned;
        }

        set {
            stunned = value;
        }
    }

    public bool IsMine {
        get {
            return photonView.isMine;
        }
    }

    public FactionManager FactionManager {
        get {
            if (manager == null) {
                manager = GetComponent<FactionManager>();
            }
            return manager;
        }

        set {
            manager = value;
        }
    }

    public Color NormalColor {
        get {
            return normalColor;
        }

        set {
            normalColor = value;
        }
    }

    public bool ColorWasSet {
        get {
            return colorWasSet;
        }

        set {
            colorWasSet = value;
        }
    }

    public PhotonView PhotonViewReference {
        get {
            return photonView;
        }
    }

    public Vector3 StartingPosition {
        get {
            return startingPos;
        }
    }

    // Use this for initialization
    void Start() {
        controllerPriority = ControllerConfig.ControllerPriority();
        Cursor.lockState = CursorLockMode.Confined;
        Cursor.visible = false;
        animator = GetComponent<Animator>();
        rigidbody = GetComponent<Rigidbody>();
        stunTimer = new Stopwatch();
        manager = GetComponent<FactionManager>();
        serverManager = FindObjectOfType<ServerManager>();
        teamManager = FindObjectOfType<TeamManager>();
        agent = GetComponent<NavMeshAgent>();
        decisionTimer = Stopwatch.StartNew();
        if (photonView.isMine) {
            //localPlayerNumber = serverManager.localPlayers;
        }
        startingPos = transform.position;
        if (teamManager.gameType == GameType.Elimination) {
            GetComponent<TrailRenderer>().enabled = true;
        }
        if (!PhotonNetwork.connected) {
            PhotonNetwork.offlineMode = true;
            PhotonNetwork.JoinRoom("");
        }
    }

    void FixedUpdate() {
    }

    // Update is called once per frame
    void Update() {
        if (localPlayerNumber == serverManager.botTurn++) {
            if (decisionTimer.ElapsedMilliseconds >= 1000) {
                if (!stunned) {
                    if (manager.color != Color.black) {
                        if (normalColor != manager.color) {
                            photonView.RPC("SetNormalColor", PhotonTargets.AllBuffered, manager.color.r, manager.color.g, manager.color.b);
                        }
                    }
                }
                if (serverPrepDone) {
                    if (photonView.isMine) {
                        if ((teamManager.teamAVictory || teamManager.teamBVictory || teamManager.eliminationGameComplete)) {
                            transform.position = startingPos;
                        }
                    }
                }
                if (stunned) {
                    foreach (GameObject item in objectsToDisableOnStun) {
                        item.SetActive(false);
                    }
                    foreach (GameObject item in objectsToEnableOnStun) {
                        item.SetActive(true);
                    }
                } else {
                    foreach (GameObject item in objectsToDisableOnStun) {
                        item.SetActive(true);
                    }
                    foreach (GameObject item in objectsToEnableOnStun) {
                        item.SetActive(false);
                    }
                }
                if (serverPrepDone) {
                    // If the game mode is CTF
                    if (teamManager.gameType == GameType.CTF) {
                        // Search for all flags
                        bool iHaveTheFlag = false;
                        foreach (EventReactor reactor in FindObjectsOfType<EventReactor>()) {
                            // Is this flag ours?
                            if (reactor.teamColor.r == manager.color.r && reactor.teamColor.g == manager.color.g && reactor.teamColor.b == manager.color.b) {
                                // Is this flag captured?
                                if (reactor.flagCaptured) {
                                    // Check if we have the enemy flag. We arent worried about our own yet if we do.
                                    if (!iHaveTheFlag) {
                                        // The flag has been captured, stop whoever stole it!
                                        if (reactor.currentPlayer != null) {
                                            target = reactor.currentPlayer.FactionManager.transform;
                                            agent.stoppingDistance = 5;
                                        } else {
                                            // This flag isn't tracking anybody now. Flag probably captured.
                                            target = reactor.opposingFlag.transform;
                                            agent.stoppingDistance = 0;
                                        }
                                    }
                                }
                            }
                            // Is this flag a different colour than us?
                            if (reactor.teamColor.r != manager.color.r
                                || reactor.teamColor.g != manager.color.g
                                || reactor.teamColor.b != manager.color.b) {
                                // Is this flag captured?
                                if (reactor.flagCaptured) {
                                    // Did we capture this flag?
                                    if (reactor.currentPlayer == this) {
                                        // Set our target to this flags enemy flag. Which is our flag.
                                        target = reactor.opposingFlag.transform;
                                        agent.stoppingDistance = 0;
                                        iHaveTheFlag = true;
                                    } else {
                                        if (reactor.currentPlayer != null) {
                                            // The flag has been captured, escort the person who captured it.
                                            target = reactor.currentPlayer.FactionManager.transform;
                                            agent.stoppingDistance = 5;
                                        } else {
                                            // This flag isn't tracking anybody now. Flag probably captured.
                                            target = reactor.transform;
                                            agent.stoppingDistance = 0;
                                        }
                                    }
                                } else {
                                    // Lets capture the flag!
                                    agent.stoppingDistance = 0;
                                    target = reactor.transform;
                                }
                            }
                        }
                    }
                    decisionTimer.Reset();
                    decisionTimer.Start();
                }
            }
            if (teamManager.gameType == GameType.Territores) {
                EventReactor closestReactor = null;
                EventReactor lastCheckedReactor = null;
                EventReactor lastCheckedInvalidReactor = null;
                foreach (EventReactor reactor in FindObjectsOfType<EventReactor>()) {
                    if (reactor.factionManager.color.r != manager.color.r
                        || reactor.factionManager.color.g != manager.color.g
                        || reactor.factionManager.color.b != manager.color.b) {
                        if (closestReactor == null) {
                            closestReactor = reactor;
                        }
                        if (Vector3.Distance(transform.position, reactor.transform.position) < Vector3.Distance(transform.position, closestReactor.transform.position)) {
                            targetSet = true;
                            closestReactor = reactor;
                        }
                        lastCheckedReactor = reactor;
                    }
                    lastCheckedInvalidReactor = reactor;
                }
                if (closestReactor != null) {
                    if (target != closestReactor) {
                        target = closestReactor.transform;
                    }
                } else {
                    if (lastCheckedReactor != null) {
                        if (target != lastCheckedReactor) {
                            target = lastCheckedReactor.transform;
                        }
                    } else {
                        if (lastCheckedInvalidReactor != null) {
                            if (target != lastCheckedInvalidReactor) {
                                target = lastCheckedInvalidReactor.transform;
                            }
                        }
                    }
                }
                Color color = target.GetComponent<FactionManager>().color;
                //if (color.r == manager.color.r && color.g == manager.color.g && color.b == manager.color.b) {
                //    foreach (EventReactor reactor in FindObjectsOfType<EventReactor>()) {
                //        if (reactor.factionManager.color.r != manager.color.r
                //            || reactor.factionManager.color.g != manager.color.g
                //            || reactor.factionManager.color.b != manager.color.b) {
                //            target = reactor.transform;
                //            targetSet = true;
                //            break;
                //        }
                //    }
            }
            if (serverManager.botTurn >= serverManager.botsSpawned) {
                serverManager.botTurn = 0;
            }
        }
        if (teamManager.gameType == GameType.Elimination) {
            PlayerController[] livePlayer = FindObjectsOfType<PlayerController>();
            AIController[] aiPlayers = FindObjectsOfType<AIController>();
            List<IControlledObject> controlledObjects = new List<IControlledObject>();
            controlledObjects.AddRange(livePlayer);
            controlledObjects.AddRange(aiPlayers);
            IControlledObject nearestPlayer = null;
            foreach (IControlledObject controlledObject in controlledObjects) {
                if (nearestPlayer == null) {
                    nearestPlayer = controlledObject;
                }
                if (Vector3.Distance(transform.position, controlledObject.FactionManager.transform.position) < Vector3.Distance(transform.position, nearestPlayer.FactionManager.transform.position)) {
                    if (!nearestPlayer.Stunned) {
                        if (controlledObject != this) {
                            nearestPlayer = controlledObject;
                        }
                    }
                }
            }
            if (nearestPlayer != null) {
                target = nearestPlayer.FactionManager.transform;
                agent.stoppingDistance = 5;
            }
        }
        if (!stunTimer.IsRunning) {
            //if (groundCheck.IsGrounded) {
            if ((teamManager.teamAVictory || teamManager.teamBVictory)) {
                agent.enabled = false;
            } else {
                agent.enabled = true;
            }
            if (lastAgentPosition == transform.position && (DateTime.Now - lastAgentPositionCheck).Seconds >= 5) {
                agent.enabled = false;
                agent.enabled = true;
                lastAgentPosition = transform.position;
                lastAgentPositionCheck = DateTime.Now;
            }
            //} else {
            //    agent.enabled = false;
            //}
            agent.enabled = !stunned;
            if (target != null) {
                if (photonView.isMine || !PhotonNetwork.offlineMode) {
                    if (!stunned) {
                        if (agent.pathEndPosition != target.position) {
                            agent.SetDestination(target.position);
                        }
                    }
                }
                if (lastFramePos != transform.position && !stunned) {
                    Animator(0, 1);
                    lastFramePos = transform.position;
                } else {
                    Animator(0, 0);
                    targetSet = false;
                }
            }
        } else {
            Animator(0, 0);
            photonView.RPC("ResetStun", PhotonTargets.AllBuffered);
        }
    }

    [PunRPC]
    void ResetStun() {
        if (stunTimer.ElapsedMilliseconds >= maxStunTime && (teamManager.gameType != GameType.Elimination || teamManager.eliminationGameComplete)) {
            stunTimer.Stop();
            stunTimer.Reset();
            manager.SetColor(normalColor.r, normalColor.g, normalColor.b);
            agent.enabled = true;
            stunned = false;
        }
    }

    [PunRPC]
    public void SetNormalColor(float r, float g, float b) {
        normalColor = new Color(r, g, b);
    }

    [PunRPC]
    public void Animator(float x, float y) {
        if (animator != null) {
            animator.SetFloat("MovementX", x);
            animator.SetFloat("MovementY", y);
        }
    }
    public virtual void Stun() {
        CmdStun();
    }
    public virtual void CmdStun() {
        photonView.RPC("RpcStun", PhotonTargets.AllBufferedViaServer);
    }
    [PunRPC]
    public virtual void Teleport(float x, float y, float z) {
        transform.position = new Vector3(x, y, z);
    }
    [PunRPC]
    public virtual void RpcStun() {
        if (!stunned) {
            if (teamManager.gameType == GameType.CTF) {
                GetComponent<TrailRenderer>().enabled = false;
            }
            agent.enabled = false;
            // Activate the stun.
            stunTimer.Start();
            // Track the players original color.
            manager.SetColor(Color.black.r, Color.black.g, Color.black.b);
            // Other code will check against this before trying to send another stun command.
            stunned = true;
            // Report that the stun was sent
            //UnityEngine.Debug.Log("Stun Sent");
        }
    }
    void OnCollisionEnter(Collision collision) {
        if (!agentHasBeenActivated) {
            agent.enabled = true;
            agentHasBeenActivated = true;
        }
    }
    void OnCollisionStay(Collision collision) {
        if (!agentHasBeenActivated) {
            agent.enabled = true;
            agentHasBeenActivated = true;
        }
    }
}