using System;
using System.Collections.Generic;
using System.Diagnostics;
using RelayLib;
using GameTypes;
using System.Runtime.CompilerServices;
namespace TingTing
{
    public class TingConcrete : Ting { }
	public abstract class Ting : RelayObjectTwo
	{
        public enum ActionEvent
        {
            START,
            STOP,
            FIRE,
        }

        public delegate void MyActionListener(Ting pTing, string pActionName, ActionEvent pEvent);
		public static readonly string TABLE_NAME = "Ting_Base";
		public Logger logger = new Logger();
		protected TingRunner _tingRunner;
        protected RoomRunner _roomRunner;
        #region PRE_TING_CREATION
        /// <summary>
        ///when a new Ting is created we need to have it created at the correct starting position,
        ///otherwise the SetupCells can't resolve their appropriate room, (used functionality in subclass Door).
        /// </summary>
        private WorldCoordinate _startingPosition = WorldCoordinate.NONE;
        private string _startingName = "unnamed";
        internal void SetInitCreateValues(string pName, WorldCoordinate pPosition)
        {
            _startingName = pName;
            _startingPosition = pPosition;
        }
        #endregion
        public virtual void Update(float dt) {}

		#region CELLS

		ValueEntry<string> CELL_name;
        ValueEntry<WorldCoordinate> CELL_position;
        ValueEntry<Direction> CELL_direction;
        ValueEntry<string> CELL_dialogueLine;
        ValueEntry<string> CELL_actionName;
        ValueEntry<bool> CELL_actionHasFired;
        ValueEntry<float> CELL_actionStartTime;
        ValueEntry<float> CELL_actionTriggerTime;
        ValueEntry<float> CELL_actionEndTime;
        ValueEntry<string> CELL_actionOtherObjectName;
		ValueEntry<string> CELL_prefab;
		ValueEntry<bool> CELL_isBeingHeld;

		protected override void SetupCells()
        {
			CELL_name = EnsureCell("name", _startingName);
            CELL_position = EnsureCell("position", _startingPosition);
            CELL_direction = EnsureCell("direction", Direction.RIGHT);
            CELL_dialogueLine = EnsureCell("dialogueLine", "");
            CELL_actionName = EnsureCell("action", "");
            CELL_actionHasFired = EnsureCell("actionHasFired", false);
            CELL_actionStartTime = EnsureCell("startTime", 0f);
            CELL_actionTriggerTime = EnsureCell("triggerTime", 0f);
            CELL_actionEndTime = EnsureCell("endTime", 0f);
            CELL_actionOtherObjectName = EnsureCell("otherObjectName", "");
			CELL_prefab = EnsureCell("prefab", "unspecified");
			CELL_isBeingHeld = EnsureCell("isBeingHeld", false);
		}

		#endregion

		#region ACTIONS

		public virtual bool CanInteractWith(Ting pTingToInteractWith) { return false; }
		public virtual void InteractWith(Ting pTingToInteractWith) { throw new NotImplementedException(); }

		public void UpdateAction(float pTime)
		{
			if(actionName != "")
			{
				if(!actionHasFired && pTime >= actionTriggerTime) {
#if DEBUG
					if(actionOtherObject == null) {
						logger.Log("Triggering action '" + actionName + "'");
					}
					else {
						logger.Log("Triggering action '" + actionName + "' with other ting '" + actionOtherObject.name + "'");
					}
#endif
                    actionHasFired = true;
                    if (_dispatchActionFire != null)
                        _dispatchActionFire(this, actionName, ActionEvent.FIRE);

				}
				if(pTime > actionEndTime) {
#if DEBUG
					logger.Log("pTime (" + pTime + ") > actionEndTime (" + actionEndTime + ")");
#endif

					StopAction();
				}
			}
		}

		protected void StartAction(string pActionName, Ting pOtherObject, float pLengthUntilTrigger, float pActionLength)
		{
#if DEBUG
			logger.Log("Starting action '" + pActionName + "'");
#endif
			actionName = pActionName;
			float worldTime = _tingRunner.worldTime;
			actionStartTime = worldTime;
			actionEndTime = worldTime + pActionLength;
			actionTriggerTime = worldTime + pLengthUntilTrigger;
			actionHasFired = false;
			actionOtherObject = pOtherObject;
            if (_dispatchActionStart != null)
                _dispatchActionStart(this, actionName, ActionEvent.START);
		}

		public void StopAction()
		{
#if DEBUG
			logger.Log("Stopping action '" + actionName + "'");
#endif
			actionName = "";
			actionOtherObject = null;
            if (_dispatchActionStop != null)
                _dispatchActionStop(this, actionName, ActionEvent.STOP);
		}

		#endregion

		#region ACCESSORS

		public string name {
			get {
				return CELL_name.data;
			}
			private set {
				CELL_name.data = value;
			}
		}

        [ShowInEditor]
        public WorldCoordinate position
        {
            get {
				return CELL_position.data;
			}
            set
            {
                if (!_roomRunner.HasRoom(value.roomName))
                {
                    throw new WorldCoordinateException("Can't place a ting in a undefined room: " + value.roomName);
                }
                CELL_position.data = value;
				// TODO: Add self to tile node!
            }
        }

		public Room room
        {
			get {
                return _roomRunner.GetRoom(CELL_position.data.roomName);
			}
		}

        public PointTileNode tile
        {
            get { return room.GetTile(localPoint); }
        }

		public IntPoint localPoint
        {
			get { return CELL_position.data.localPosition; }
		}

        public IntPoint worldPoint
        {
            get { return room.worldPosition + this.localPoint; }
        }

		[ShowInEditor]
		public Direction direction {
			get {
				return CELL_direction.data;
			}
			set {
				CELL_direction.data = value;
			}
		}

		[ShowInEditor]
		public string dialogueLine {
			get {
				return CELL_dialogueLine.data;
			}
			set {
				CELL_dialogueLine.data = value;
			}
		}

		[EditableInEditor]
		public string actionName {
			get {
				return CELL_actionName.data;
			}
			set {
				CELL_actionName.data = value;
			}
		}

		[ShowInEditor]
		public bool actionHasFired {
			get {
				return CELL_actionHasFired.data;
			}
			set {
				CELL_actionHasFired.data = value;
			}
		}

		//[ShowInEditor]
		public float actionStartTime {
			get {
                return CELL_actionStartTime.data;
			}
			set {
				CELL_actionStartTime.data = value;
			}
		}

		//[ShowInEditor]
		public float actionTriggerTime {
			get {
                return CELL_actionTriggerTime.data;
			}
			set {
				CELL_actionTriggerTime.data = value;
			}
		}

		//[ShowInEditor]
		public float actionEndTime {
			get {
				return CELL_actionEndTime.data;
			}
			set {
				CELL_actionEndTime.data = value;
			}
		}

		[ShowInEditor]
		public string prefab {
			get {
                return CELL_prefab.data;
			}
			set {
				CELL_prefab.data = value;
			}
		}

		[ShowInEditor]
		public bool isBeingHeld {
			get {
                return CELL_isBeingHeld.data;
			}
			set {
				CELL_isBeingHeld.data = value;
			}
		}

		public Ting actionOtherObject {
			get
            {
				if(CELL_actionOtherObjectName.data == "")
					return null;
				else
                    return _tingRunner.GetTing(CELL_actionOtherObjectName.data);
			}
			set
            {
                if (value == null)
                    CELL_actionOtherObjectName.data = "";
                else
                    CELL_actionOtherObjectName.data = value.name;
			}
		}

		internal void SetupBaseRunners(TingRunner pTingRunner, RoomRunner pRoomRunner)
		{
            _roomRunner = pRoomRunner;
			_tingRunner = pTingRunner;
		}

		public virtual bool canBePickedUp {
			get {
				return false;
			}
		}

		public virtual IntPoint[] interactionPoints {
            get {
				return new IntPoint[] {
					localPoint + IntPoint.Down,
					localPoint + IntPoint.Up,
					localPoint + IntPoint.Left,
					localPoint + IntPoint.Right
				};
			}
        }

		public virtual string tooltipName
		{
			get {
				return "Ting";
			}
		}

		public virtual string verbDescription
		{
			get {
				return "Use [NAME]";
			}
		}

        protected float worldTime { get { return _tingRunner.worldTime; } }
        private event MyActionListener _dispatchActionStart;
        private event MyActionListener _dispatchActionStop;
        private event MyActionListener _dispatchActionFire;
        public void AddActionListener( MyActionListener pActionListener, ActionEvent pEventType)
        {
            switch (pEventType)
            {
                case ActionEvent.START: _dispatchActionStart += pActionListener; break;
                case ActionEvent.FIRE: _dispatchActionFire += pActionListener; break;
                case ActionEvent.STOP: _dispatchActionStop += pActionListener; break;
            }
        }

        public void RemoveActionListner(MyActionListener pActionListener, ActionEvent pEventType)
        {
            switch (pEventType)
            {
                case ActionEvent.START: _dispatchActionStart -= pActionListener; break;
                case ActionEvent.FIRE: _dispatchActionFire -= pActionListener; break;
                case ActionEvent.STOP: _dispatchActionStop -= pActionListener; break;
            }
        }

		#endregion
	}
}