using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;


#region Floor definition
public class Floor {

    private GameObject Object;
    public ElevatorDoor Door;

    public Vector3 Position {
        get {
            return Object.transform.position;
        }
    }

    public uint Number {
        get {
            return uint.Parse(Regex.Match(Object.name, @"\d+", RegexOptions.RightToLeft).Value);
        }
    }

    public Floor(GameObject floorobject, GameObject doorobject) {
        this.Object = floorobject;
        this.Door = new ElevatorDoor(doorobject);
    }


    public class ElevatorDoor {
        public enum DoorState { Open, Closed, Opening, Closing };
        public DoorState State { get; private set; }

        private float OpenedTime = 0; // when the door was last opened
        private GameObject Object;
        private Vector3 ScaleTransform = Vector3.left * Time.deltaTime * Elevator.DoorAnimationSpeed;

        public ElevatorDoor(GameObject gameobject) {
            this.Object = gameobject;
            State = DoorState.Closed;
        }

        public static ElevatorDoor GetForFloor(uint floor) {
            GameObject DoorObject = GameObject.Find("ElevatorDoor"+floor);
            return new ElevatorDoor(DoorObject);
        }

        public void Close() {
            State = DoorState.Closing;
        }

        public void Open() {
            State = DoorState.Opening;
            Debug.Log("Elevator: Opening door: "+Object.name);
        }

        public void Update() {
            switch (State) {
                case DoorState.Opening:
                    if (Object.transform.localScale.x > 0.0f) {
                        Object.transform.localScale += ScaleTransform;
                    } else if (Object.transform.localScale.x <= 0.0f) {
                        Object.transform.localScale = new Vector3(0.0f, 1.0f, 1.0f);
                        State = DoorState.Open;
                        OpenedTime = Time.time;
                    }
                break;

                case DoorState.Closing:
                    if (Object.transform.localScale.x < 1.0f) {
                        Object.transform.localScale -= ScaleTransform;
                    } else if (Object.transform.localScale.x >= 1.0f) {
                        Object.transform.localScale = new Vector3(1.0f, 1.0f, 1.0f);
                        State = DoorState.Closed;
                    }
                break;

                case DoorState.Open:
                    if ( (Time.time - OpenedTime) >= Elevator.DoorStayOpenSeconds ) {
                        State = DoorState.Closing;
                        if (Elevator.PrintDebugMessages) {
                            Debug.Log("Elevator: Closing " + Object.name);
                        }
                    }
                break;
            }
        }

    }
}
#endregion



#region ElevatorCar definition
public class ElevatorCar {

    public enum CarState { Moving, Still };
    public CarState State { get; private set; }


    private Floor TargetFloor;
    private float Speed = 0.05f;
    private GameObject Object;

    public ElevatorCar(GameObject carobject, float speed) {
        Object = carobject;
        Speed = speed;
        State = CarState.Still;
    }

    public void SetTargetFloor(Floor floor) {
        TargetFloor = floor;
        State = CarState.Moving;
        if (Elevator.PrintDebugMessages) {
            Debug.Log("Elevator target floor set to "+floor.Number);
        }
    }

    // returns the Floor object on arrival, otherwise null
    public Floor Update() {
        if (State != CarState.Moving) {
            return null;
        }

        float epsilon = 0.05f;
        Vector3 TargetPosition = TargetFloor.Position;
        Vector3 CarPosition = Object.transform.position;
        Vector3 TransformVector = Vector3.up * Speed * Time.deltaTime;

        if (Mathf.Abs (CarPosition.y - TargetPosition.y) > epsilon) {
            if (CarPosition.y < TargetPosition.y) {
                Object.transform.position += TransformVector;
            }
            if (CarPosition.y > TargetPosition.y) {
                Object.transform.position -= TransformVector;
            }
            State = CarState.Moving;
        // close enough to target floor
        } else {
            CarPosition = TargetPosition;
            State = CarState.Still;
            return TargetFloor;
        }
        return null;
    }

    public bool IsMoving() {
        return State == CarState.Moving;
    }
}
#endregion



#region Elevator definition
public class Elevator : MonoBehaviour {

    public static float DoorAnimationSpeed = 0.7f;
    public static float DoorStayOpenSeconds = 4.0f;
    public static bool PrintDebugMessages = true;

    public uint CurrentFloor = 0;
    public GameObject[] TargetFloors;
    public float ElevatorSpeed = 0.01f;

    private Floor[] Floors;
    private ElevatorCar Car;


    // Use this for initialization
    void Start () {
        GameObject CarObject = GameObject.Find("ElevatorCar");
        if (CarObject == null) {
            Debug.LogError("Missing 'CarObject'");
        }
        Car = new ElevatorCar(CarObject, ElevatorSpeed);
        int FloorCount = TargetFloors.Length;

        // initialize an array of Floors the elevator can go to. Each floor has it's own elevator door.
        Floors = new Floor[FloorCount];
        for (int i = 0; i < TargetFloors.Length; i++) {
            Floors[i] = new Floor(TargetFloors[i], GameObject.Find("ElevatorDoor"+i));
        }
        Car.SetTargetFloor(Floors[CurrentFloor]);
    }

    // Update is called once per frame
    void Update () {
        Floor floor = Car.Update();
        // car has just arrived on target floor
        if (floor != null) {
            if (Elevator.PrintDebugMessages) {
                Debug.Log("Elevator has arrived safely on floor " + floor.Number);
            }
            floor.Door.Open();
        }
        // todo: floorcollection class?
        foreach (Floor f in Floors) {
            f.Door.Update();
        }
        SelectFloor();
    }

    // For easier testing
    void SelectFloor() {
        // this probably should not be called when debug messages are supressed
        if (!Elevator.PrintDebugMessages) {
            Debug.Log("Elevator: F-key floor selection enabled");
        }
        if (Input.GetKeyDown(KeyCode.F1)) {
            Car.SetTargetFloor(Floors[0]);
        } else if (Input.GetKeyDown(KeyCode.F2)) {
            Car.SetTargetFloor(Floors[1]);
        } else if (Input.GetKeyDown(KeyCode.F3)) {
            Car.SetTargetFloor(Floors[2]);
        }
    }

}
#endregion