using System;
using System.Collections.Generic;
using System.Data;
using EPInterface.Data;
using System.ServiceModel;
using Aitex.Core.Util;
using Aitex.Core.WCF;
using EPInterface.Datas;
using MECF.Framework.Common.Utilities;

namespace EPInterface
{
    public class EPDClient : Singleton<EPDClient>
    {
 
        private IEPDService _service;
        public IEPDService Service
        {
            get
            {
                if (_service == null)
                {
 
                        _service = new EPDServiceClient();
                }

                return _service;
            }
        }
    }

    public class EPDServiceClient : ServiceClientWrapper<IEPDService>, IEPDService
    {
        public EPDServiceClient()
            : base("Client_IEPDService", "EPDService")
        {
        }

        public void SetModel(int channel,string name, string model)
        {
            Invoke(svc => {  svc.SetModel(channel, name, model); });
        }

        public int Heartbeat(int counter)
        {
            int result = 0;

            Invoke(svc => { result = svc.Heartbeat(counter); });

            return result;
        }

        public void Online()
        {
            Invoke(svc => { svc.Online(); });
        }
        public void Offline()
        {
            Invoke(svc => { svc.Offline(); });
        }

        public int IsOnline()
        {
            //bool result = false;
            //Invoke(svc => { result = svc.IsOnline(); });
            //return result;
            int result = -1;
            Invoke(svc => { result = svc.IsOnline(); });
            return result;
        }

        public void SetOption(string name, string value)
        {
            Invoke(svc => { svc.SetOption(name, value); });
        }

        public string GetOption(string name )
        {
            string result = string.Empty;
            Invoke(svc => { result = svc.GetOption(name); });
            return result;
        }

        public void RecipeStart(int channel, string name)
        {
            Invoke(svc => { svc.RecipeStart(channel, name); });
        }
        public void RecipeStop(int channel)
        {
            Invoke(svc => { svc.RecipeStop(channel); });
        }
        public void Start(int channel,int idx, string name, string model)
        {
            Invoke(svc => {  svc.Start(channel, idx, name, model); });
        }

        public void StartByConfig(int channel, int idx, string name, EPDConfig config)
        {
            Invoke(svc => { svc.StartByConfig(channel, idx, name, config); });
        }

        public void Stop(int channel)
        {
            Invoke(svc => {  svc.Stop(channel); });
        }

        public void Pause(int channel)
        {
            Invoke(svc => {  svc.Pause(channel); });
        }

        public void Resume(int channel)
        {             
            Invoke(svc => {  svc.Resume(channel); });
        }
        public int QueryChannels()
        {
            int result = 0;
            Invoke(svc => { result = svc.QueryChannels(); });
            return result;
        }

        public List<string> QueryChannelNames()
        {
            List<string> result = new List<string>();
            Invoke(svc => { result = svc.QueryChannelNames(); });
            return result;
        }

        public string QueryChannelName(int channel)
        {
            string result = "";
            Invoke(svc => { result = svc.QueryChannelName(channel); });
            return result;
        }

        public Tuple<string,string> QueryModel(int channel)
        {
            Tuple<string, string> result = null;
            Invoke(svc => { result = svc.QueryModel(channel); });
            return result;
        }

        public double[] QueryWave(int channel)
        {
            double[] result = null;
            Invoke(svc => { result = svc.QueryWave(channel); });
            return result;
        }

        public CRawDataItem QueryData(int channel)
        {
            CRawDataItem result = default(CRawDataItem) ;
            Invoke(svc => { result = svc.QueryData(channel); });
            return result;
        }

        public EPDState QueryState(int channel)
        {
            EPDState result = EPDState.UnSampling;
            Invoke(svc => { result = svc.QueryState(channel); });
            return result;
        }

        public bool QueryRecordState(int channel)
        {
            bool result = false;
            Invoke(svc => { result = svc.QueryRecordState(channel); });
            return result;
        }

        public long QueryRecipeTime(int channel)
        {
            long result = 0;
            Invoke(svc => { result = svc.QueryRecipeTime(channel); });
            return result;
        }
        public List<long> QueryStepTime(int channel)
        {
            List<long> result = new List<long>();
            Invoke(svc => { result = svc.QueryStepTime(channel); });
            return result;
        }

        public List<string> QueryConfigList()
        {
            List<string> result = new List<string>();
            Invoke(svc => { result = svc.QueryConfigList(); });
            return result;
        }

        public string QueryConfig(string name)
        {
            string result = string.Empty;
            Invoke(svc => { result = svc.QueryConfig(name); });
            return result;
        }

        public void Reset()
        {
            Invoke(svc => svc.Reset());
        }

        public string GetData(string name)
        {
            string result = string.Empty;
            Invoke(svc => { result = svc.GetData(name); });
            return result;
        }

        public Dictionary<string, string> GetOptions(List<string> names)
        {
            var result = new Dictionary<string, string>();
            Invoke(svc => { result = svc.GetOptions(names); });
            return result;
        }

        public bool SetOptions(Dictionary<string, string> dic, string cmd, int channel)
        {
            Invoke(svc => { svc.SetOptions(dic, cmd, channel); });
            return true;
        }

        public void ManualEPD(int channel)
        {
            Invoke(svc => svc.ManualEPD(channel));
        }

        public List<string> QueryChamberNames()
        {
            var result = new List<string>();
            Invoke(svc => { result = svc.QueryChamberNames(); });
            return result;
        }

        public double[] QueryWaveIEP(int channel)
        {
            double[] result = null;
            Invoke(svc => { result = svc.QueryWaveIEP(channel); });
            return result;
        }

        public RawDataItem QueryRawData(int channel)
        {
            var result = default(RawDataItem);
            Invoke(svc => { result = svc.QueryRawData(channel); });
            return result;
        }

        public List<double[]> QuerySpectrum(int channel)
        {
            var result = new List<double[]>();
            Invoke(svc => { result = svc.QuerySpectrum(channel); });
            return result;
        }

        public List<string> QueryHistoryDataList(int channel, string date)
        {
            List<string> result = null;
            Invoke(svc => { result = svc.QueryHistoryDataList(channel, date); });
            return result;
        }

        public byte[] QueryHistoryData(int channel, string date, string name)
        {
            byte[] result = null;
            Invoke(svc => { result = svc.QueryHistoryData(channel, date, name); });
            return result;
        }

        public bool QueryConnectState(int channel)
        {
            bool sta = false;
            Invoke(svc => { sta = svc.QueryConnectState(channel); });
            return sta;
        }

        public string QuerySpectralStatus()
        {
            var status = string.Empty;
            Invoke(svc => { status = svc.QuerySpectralStatus(); });
            return status;
        }

        public List<string> QuerySpectralSerials()
        {
            List<string> result = null;
            Invoke(svc => { result = svc.QuerySpectralSerials(); });
            return result;
        }

        public string QueryChannelSerial(int channel)
        {
            string result = null;
            Invoke(svc => { result = svc.QueryChannelSerial(channel); });
            return result;
        }

        public string QueryChannelVersion(int channel)
        {
            string result = null;
            Invoke(svc => { result = svc.QueryChannelVersion(channel); });
            return result;
        }


        public bool DeleteConfig(string name)
        {
            bool result = false;
            Invoke(svc => { result = svc.DeleteConfig(name); });
            return result;
        }

        public bool SaveConfig(string name, string xml)
        {
            bool result = false;
            Invoke(svc => { result = svc.SaveConfig(name, xml); });
            return result;
        }

        public int QueryIntrgrationTime(int channel)
        {
            int ms = 0;
            Invoke(svc => { ms = svc.QueryIntrgrationTime(channel); });
            return ms;
        }

        public void SetIntrgrationTime(int channel, int ms)
        {
            Invoke(svc => svc.SetIntrgrationTime(channel, ms));
        }

        public void SetFlashMode(int channel, bool mode)
        {
            Invoke(svc => svc.SetFlashMode(channel, mode));
        }

        public int QueryRunStatus()
        {
            int sta = 0;
            Invoke(svc => { sta = svc.QueryRunStatus(); });
            return sta;
        }


        public void SetRunStatus(int runSta)
        {
            Invoke(svc => svc.SetRunStatus(runSta));
        }

        public int QueryOperateMode()
        {
            int mode = 0;
            Invoke(svc => { mode = svc.QueryOperateMode(); });
            return mode;
        }

        public void SetOperateMode(int mode)
        {
            Invoke(svc => svc.SetOperateMode(mode));
        }

        public void ClearBackground(int channel)
        {
            Invoke(svc => svc.ClearBackground(channel));
        }

        public double QueryClearBackgroundPercent(int channel)
        {
            var res = 0.0;
            Invoke(svc => { res = svc.QueryClearBackgroundPercent(channel); });
            return res;
        }

        public RawDataType QueryRawType(int channel)
        {
            var res = RawDataType.OES;
            Invoke(svc => { res = svc.QueryRawType(channel); });
            return res;
        }

        public int QueryWaveFactorStatus(int channel)
        {
            int res = 0;
            Invoke(svc => { res = svc.QueryWaveFactorStatus(channel); });
            return res;
        }

    }
}