using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.Jobs;

namespace Aitex.Core.Common
{
    public enum WaferSize
    {
        WS0,    //undefine, initialize status
        WS3,
        WS4,
        WS6,
        WS150,  //150mm
        WS159,  //150mm with tray
        WS8,
        WS12,
    }
    

    public enum WaferStatus
	{
		Empty = 0,
		Normal = 1,
		Crossed = 3,
		Double = 7,
		Unknown = 8,
		Dummy = 4
	}

	public enum EnumWaferProcessStatus
	{
		Idle = 0,
		InProcess, 
		Completed,
		Failed,
        Wait
	}

    public enum EnumWaferChuckStatus
    {
        Init = 0,
        Chucked,
        Dechucked,
    }

    [Serializable]
    [DataContract]
	public class WaferInfo : NotifiableItem
	{
		public bool IsEmpty
		{
			get { return Status == WaferStatus.Empty; }
		}

		private bool _isDuplicated;
		[DataMember]
		public bool IsDuplicated
        {
			get { return _isDuplicated; }
			set
            {
				_isDuplicated = value;
				InvokePropertyChanged("WaferID");

			}
        }

		private string waferID;
		[DataMember]
		public string WaferID
		{
			get
			{
				return waferID;
			}
			set
			{
				waferID = value;
			    InvokePropertyChanged("WaferID");
			}
		}

		private string _waferOrigin;
		[DataMember]
		public string WaferOrigin
		{
			get
			{
				return _waferOrigin;
			}
			set
			{
				_waferOrigin = value;
			    InvokePropertyChanged("WaferOrigin");
			}
		}


		private string laserMarker;
		[DataMember]
		public string LaserMarker
		{
			get
			{
				return laserMarker;
			}
			set
			{
				laserMarker = value;
			    InvokePropertyChanged("LaserMarker");
			}
		}

		private string t7Code;
		[DataMember]
		public string T7Code
		{
			get
			{
				return t7Code;
			}
			set
			{
				t7Code = value;
			    InvokePropertyChanged("T7Code");
			}
		}
		

	    [DataMember]
	    public string LotId { get; set; }


	    [DataMember]
	    public string TransFlag { get; set; }

        private WaferStatus status;
		[DataMember]
		public WaferStatus Status
		{
			get
			{
				return status;
			}
			set
			{
				status = value;
			    InvokePropertyChanged("Status");
			}
		}

        [DataMember]
		public int Station
		{
			get;
			set;
		}

		[DataMember]
		public int Slot
		{
			get;
			set;
		}

		[DataMember]
		public int OriginStation
		{
			get;
			set;
		}

		[DataMember]
		public int OriginSlot
		{
			get;
			set;
		}
        [DataMember]
        public string OriginCarrierID
        {
            get;
            set;
        }

        [DataMember]
		public int SourceStation
		{
			get;
			set;
		}

		[DataMember]
		public int SourceSlot
		{
			get;
			set;
		}

		[DataMember]
		public int DestinationStation
		{
			get;
			set;
		}

		[DataMember]
		public int DestinationSlot
		{
			get;
			set;
		}

		[DataMember]
		public int Notch
		{
			get;
			set;
		}

        [DataMember]
        public WaferSize Size
        {
            get;
            set;
        }
		[DataMember]
		public string SequenceName
		{
			get;
			set;
		}


		private EnumWaferProcessStatus processState;
		[DataMember]
		public EnumWaferProcessStatus ProcessState
		{
			get
			{
				return processState;
			}
			set
			{
				processState = value;
			    InvokePropertyChanged("ProcessState");
			}
		}

		private EnumWaferChuckStatus chuckState;
		[DataMember]
		public EnumWaferChuckStatus ChuckState
        {
			get
            {
				return chuckState;
            }
			set
            {
				chuckState = value;
				InvokePropertyChanged("ChuckState");
            }
        }

		private bool isSource;
	    [DataMember]
        public bool IsSource
		{
			get
			{
				return isSource;
			}
			set
			{
				isSource = value;
			    InvokePropertyChanged("IsSource");
			}
		}

		private bool isDestination;
	    [DataMember]
        public bool IsDestination
		{
			get
			{
				return isDestination;
			}
			set
			{
				isDestination = value;
				InvokePropertyChanged("IsDestination");
			}
		}

	    [DataMember]
        public Guid InnerId { get; set; }

	    [DataMember]
        public ProcessJobInfo ProcessJob { get; set; }

	    [DataMember]
        public int NextSequenceStep { get; set; }

        public WaferInfo()
		{
			InnerId = Guid.Empty;
			_isDuplicated = false;
		}

		public WaferInfo(string waferID, WaferStatus status = WaferStatus.Empty) : this()
		{
			this.WaferID = waferID;
			this.Status = status;
		}
 
		public void Update(WaferInfo source)
		{
		    InnerId = source.InnerId;

			WaferID = source.waferID;
			WaferOrigin = source.WaferOrigin;
			LaserMarker = source.LaserMarker;
			T7Code = source.T7Code;
			Status = source.Status;
			ProcessState = source.ProcessState;
			ChuckState = source.ChuckState;
			IsSource = source.IsSource;
			IsDestination = source.IsDestination;
			IsDuplicated = source.IsDuplicated;

			Station = source.Station;
			Slot = source.Slot;
			OriginStation = source.OriginStation;
			OriginSlot = source.OriginSlot;
            if(source.OriginCarrierID!=null) OriginCarrierID = source.OriginCarrierID;
			SourceStation = source.SourceStation;
			SourceSlot = source.SourceSlot;
			DestinationStation = source.DestinationStation;
			DestinationSlot = source.DestinationSlot;
			Notch = source.Notch;
            Size  = source.Size;

		    TransFlag = source.TransFlag;
		    LotId = source.LotId;

		    ProcessJob = source.ProcessJob;
		    NextSequenceStep = source.NextSequenceStep;
		}

	    public void SetEmpty()
	    {
            this.InnerId = Guid.Empty;
	        
	        this.WaferID = string.Empty;

	        this.WaferOrigin = string.Empty;

	        this.LaserMarker = string.Empty;
	        this.T7Code = string.Empty;

            this.Status = (int)WaferStatus.Empty;
 
	        this.ProcessState = EnumWaferProcessStatus.Idle;
			this.ChuckState = EnumWaferChuckStatus.Init;

	        this.IsSource = false;

	        this.IsDestination = false;
			this.IsDuplicated = false;
            
	        this.Station = 0;
	        this.Slot = 0;

	        this.OriginStation = 0;

	        this.OriginSlot = 0;

	        this.SourceStation = 0;

	        this.SourceSlot = 0;

	        this.DestinationStation = 0;

	        this.DestinationSlot = 0;

	        this.Notch = 0;

	        //this.Size = WaferSize.WS0; //wafersize 保留最后的一次的记录


            this.TransFlag = string.Empty;

	        this.LotId = string.Empty;

	        this.ProcessJob = null;

	        this.NextSequenceStep = 0;
	    }

		public WaferInfo Clone(WaferInfo source)
		{
			WaferInfo newValue = new WaferInfo();
			newValue.InnerId = source.InnerId;

			newValue.WaferID = source.waferID;
			newValue.WaferOrigin = source.WaferOrigin;
			newValue.LaserMarker = source.LaserMarker;
			newValue.T7Code = source.T7Code;
			newValue.Status = source.Status;
			newValue.ProcessState = source.ProcessState;
			newValue.ChuckState = source.ChuckState;
			newValue.IsSource = source.IsSource;
			newValue.IsDestination = source.IsDestination;
			newValue.IsDuplicated = source.IsDuplicated;

			newValue.Station = source.Station;
			newValue.Slot = source.Slot;
			newValue.OriginStation = source.OriginStation;
			newValue.OriginSlot = source.OriginSlot;
			if (source.OriginCarrierID != null) newValue.OriginCarrierID = source.OriginCarrierID;
			newValue.SourceStation = source.SourceStation;
			newValue.SourceSlot = source.SourceSlot;
			newValue.DestinationStation = source.DestinationStation;
			newValue.DestinationSlot = source.DestinationSlot;
			newValue.Notch = source.Notch;
			newValue.Size = source.Size;
			newValue.TransFlag = source.TransFlag;
			newValue.LotId = source.LotId;
			
			newValue.NextSequenceStep = source.NextSequenceStep;
			if(source.ProcessJob != null)
            {
				newValue.ProcessJob = new ProcessJobInfo();
				if(source.ProcessJob.Sequence != null)
                {
					newValue.ProcessJob.Sequence = new SequenceInfo(source.ProcessJob.Sequence.Name);
					newValue.ProcessJob.Sequence.InnerId = source.ProcessJob.Sequence.InnerId;
					newValue.ProcessJob.Sequence.ThicknessType = source.ProcessJob.Sequence.ThicknessType;
					foreach(var step in source.ProcessJob.Sequence.Steps)
                    {
						var newStep = new SequenceStepInfo();
						newStep.StepModules = new List<MECF.Framework.Common.Equipment.ModuleName>(step.StepModules.ToArray());
						newStep.StepParameter = step.StepParameter.ToDictionary(entry => entry.Key, entry => entry.Value);

						newValue.ProcessJob.Sequence.Steps.Add(newStep);
                    }
                }
            }

			return newValue;
		}
	}

	[Serializable]
	[DataContract]
	public class DulicatedWaferInfo
	{
		[DataMember]
		public Guid waferId { get; set; }

		[DataMember]
		public int source { get; set; }

		[DataMember]
		public int sourceSlot { get; set; }

		[DataMember]
		public int destination { get; set; }

		[DataMember]
		public int destSlot { get; set; }

		public DulicatedWaferInfo(Guid id, int Source, int SrcSlot, int Destination, int DestSlot)
		{
			waferId = id;
			source = Source;
			sourceSlot = SrcSlot;
			destination = Destination;
			destSlot = DestSlot;
		}
	}
}