using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

using BAI.Systems.Common;
using BAI.Systems.Common.Substrates;
using BAI.Systems.Devices.LoadPort;
using BAI.Systems.Common.Carriers;
using BAI.Systems.Common.Controls;
using BAI.Systems.Devices.LightTower;
using BAI.Systems.Modules.EFEM;

namespace VirgoRT.Devices.EFEM
{
    public class BrooksEFEMSim :  EfemRemoteProxy
    {
        private Dictionary<string, LoadPortSim> _loadports;


        public BrooksEFEMSim(string moduleName, string clientName) : base(moduleName, clientName)
        {
            _loadports = new Dictionary<string, LoadPortSim>();
            _loadports.Add("PortA", new LoadPortSim("EFEM.LoadPortA", clientName));
            _loadports.Add("PortB", new LoadPortSim("EFEM.LoadPortB", clientName));
            _loadports.Add("PortC", new LoadPortSim("EFEM.LoadPortC", clientName));
            _loadports.Add("PortD", new LoadPortSim("EFEM.LoadPortD", clientName));
        }
        override public  void Initialize()
        {
            asyncSleep(5000);
        }

        override public WaferPresenceAtHost[] GetWaferPresence(string hostSearchString)
        {
            return new WaferPresenceAtHost[0];
        }

        override public void GetWafer(string endEffecter, string fromLocation)
        {
            asyncSleep(2000);
        }
        override public void PutWafer(string endEffecter, string toLocation)
        {
            asyncSleep(2000);
        }

        override public void MoveToReadyGet(string endEffecter, string fromLocation)
        {
            asyncSleep(2000);
        }

        override public void ExtendEndEffecter(string endEffecter, string location, VerticalOffsetFromWafer verticalOffset)
        {
            asyncSleep(2000);
        }

        override public void RetractEndEffecter(string endEffecter)
        {
            asyncSleep(2000);
        }

        override public WaferAlignmentResult AlignWafer(string aligner, WaferAlignFeature feature, double angleDegree)
        {
            asyncSleep(2000);
            return new WaferAlignmentResult(0, 0, 0);
        }

        override public void ClampCarrier(string device)
        {
            asyncSleep(2000);
        }

        override public void UnclampCarrier(string device)
        {
            asyncSleep(2000);
        }
        override public void MoveCarrierPortToLocation(string device, string location)
        {
            asyncSleep(2000);
        }

        override public  WaferPresenceAtHost[] OpenAndMapCarrier(string loadport)
        {
            asyncSleep(5000);
            var mapdata = new WaferPresenceAtHost[25];
            for (int i = 0; i < mapdata.Length; i++)
            {
                string slot = $"{loadport}.Slot{i + 1}";
                mapdata[i] = new WaferPresenceAtHost(slot, WaferPresenceState.Present);
            }


            return mapdata;
        }
        override public WaferPresenceAtHost[] CloseAndMapCarrier(string loadport)
        {
            asyncSleep(2000);
            var mapdata = new WaferPresenceAtHost[25];
            for (int i = 0; i < mapdata.Length; i++)
            {
                string slot = $"{loadport}.Slot{i+1}";
                mapdata[i] = new WaferPresenceAtHost(slot, WaferPresenceState.Present);
            }


            return mapdata;

        }

        override public  void ClearAlarm()
        {
            asyncSleep(500);
        }

        public override string ReadCarrierId(string loadPort)
        {
            return "CST:C082259     TYPE:CST25_AU   LOT:AF2403      QTY:24          FLOW:033000     STATUS:HOLD     PRI:3-1         PD:0418A        CSRLOT:         CLEAN:2021/11/14 19:57:50       EQPGRP:DUMMY    STAGE:CP-TEST1  RECIPE:DUMMY    EMP:N           ";
        }
        override public void WriteCarrierId(string loadPort, string id)
        {
            asyncSleep(500);
        }

        override public void FlipHost(string host, SubstrateHostOrientation desiredOrientation)
        {
            asyncSleep(2000);
        }

        override public ILoadPortCtrl GetLoadPortCtrl(string loadport)
        {
            return _loadports[loadport];
        }

        public static void asyncSleep(int millisecondsDelay)
        {
            var t = Task.Run(async delegate {
                await Task.Delay(millisecondsDelay);
                return 0;
            });
            t.Wait();
        }
    }


    public class LightTowerSim: LightTowerLocalProxy
    {
        public LightTowerSim(string deviceName, string clientName) : base(deviceName, clientName)
        {
        }

        override public UiIndicatorState GetLightTowerComponentState(LightTowerComponent signal)
        {
            return UiIndicatorState.On;
        }
        override  public LightTowerSignalState[] GetLightTowerState()
        {

            return new LightTowerSignalState[0];
        }
        override public void SetLightTowerComponentState(LightTowerComponent signal, UiIndicatorState state)
        {
            BrooksEFEMSim.asyncSleep(500);
        }
        override public void SetLightTowerState(LightTowerSignalState[] state)
        {
            BrooksEFEMSim.asyncSleep(500);
        }
    }

    public class LoadPortSim : LoadPortRemoteProxy
    {
        public LoadPortSim(string deviceName, string clientName) : base(deviceName, clientName)
        {
        }

        override public void DockCarrier()
        {
            BrooksEFEMSim.asyncSleep(5000);
        }

        override public void UndockCarrier()
        {
            BrooksEFEMSim.asyncSleep(5000);
        }
    }
}