using MECF.Framework.Common.Equipment;
using Venus_RT.Modules.Schedulers;
using Venus_RT.Scheduler;
using Aitex.Core.RT.Routine;
using System.Collections.Generic;

namespace Venus_RT.Modules
{
    public class TransferModule
    {
        protected SchedulerEfemRobot _efemRobot = new SchedulerEfemRobot();

        protected SchedulerLoadPort _lp1 = new SchedulerLoadPort(ModuleName.LP1);
        protected SchedulerLoadPort _lp2 = new SchedulerLoadPort(ModuleName.LP2);

        protected SchedulerAligner _aligner1 = new SchedulerAligner(ModuleName.Aligner1);
        protected SchedulerAligner _aligner2 = new SchedulerAligner(ModuleName.Aligner2);
        protected SchedulerAligner _cooling1 = new SchedulerAligner(ModuleName.Cooling1);
        protected SchedulerAligner _cooling2 = new SchedulerAligner(ModuleName.Cooling2);

        protected SchedulerPM _pma = new SchedulerPM(ModuleName.PMA);
        protected SchedulerPM _pmb = new SchedulerPM(ModuleName.PMB);

        public TransferModule()
        {

        }


        protected SchedulerModule GetModule(string name)
        {
            switch (ModuleHelper.Converter(name))
            {
                case ModuleName.LP1:
                    return _lp1;
                case ModuleName.LP2:
                    return _lp2;

                case ModuleName.Aligner1:
                    return _aligner1;

                case ModuleName.Aligner2:
                    return _aligner2;

                case ModuleName.Cooling1:
                    return _cooling1;

                case ModuleName.Cooling2:
                    return _cooling2;
                case ModuleName.EfemRobot:
                    return _efemRobot;
                case ModuleName.PMA:
                    return _pma;
                case ModuleName.PMB:
                    return _pmb;
            }

            return null;
        }
    }

    public interface IAutoTransfer
    {
        bool HasJobRunning
        {
            get;
        }
        Result Monitor();
        bool CheckAllJobDone();

        bool CheckJobJustDone(out string sJobName);
        Result Start(params object[] objs);

        void Map(string moduleName);
        bool CheckRecipeUsedInJob(string pathName);

        bool CheckSequenceUsedInJob(string pathName);

        void CreateJob(Dictionary<string, object> param);

        void AbortJob(string jobName);

        void StopJob(string jobName);
        void ResumeJob(string jobName);

        void PauseJob(string jobName);

        void StartJob(string jobName);

        void ResetIdlePurgeTime(string module);
        void ResetIdleCleanTime(string module);

        void Clear();
    }
}