using Aurora.Api;
using System;
using System.Collections.Generic;
using VisionCommon;
using System.Reactive.Linq;

namespace VisionLight {
    /// <summary>
    /// Light Hub
    /// </summary>
    public class LightHub : IDisposable {
        private Logger _VisionLog = new Logger(typeof(LightHub).Name, VisionKeys.LogKey);
        private static Logger _Logger = new Logger("LightHub");
        private static readonly object _Lock = new object();
        private static readonly object _LightConfigLock = new object();
        private Dictionary<string, LightConfig> _lightConfigs = new Dictionary<string, LightConfig>();

        private IEventObservable _EventObservable;

        private static LightHub _instance;
        /// <summary>
        /// 싱글턴 객체 instance
        /// </summary>
        public static LightHub Instance {
            get {
                lock (_Lock) {
                    try {
                        if (_instance == null)
                            _instance = new LightHub();

                        return _instance;
                    }
                    catch (Exception e) {
                        _Logger.FuncE(e.Message);
                    }

                    return null;
                }
            }
        }

        private LightHub() {
            _EventObservable = VisionEnv.AuroraEnv.EventObservable;

            SetLightConfig();
            SetObservable();
        }

        private void SetObservable() {
            Observable.Merge(
                VisionEnv.AuroraEnv.EventObservable.AsObservable(AuroraSysEvent.SYS_DEVICE_ACTIVATED))
                .Subscribe(_ => SetLightConfig());
        }

        private void SetLightConfig() {
            lock (_LightConfigLock) {
                _lightConfigs.Clear();
                IEnumerable<Device> _Devices = VisionEnv.AuroraEnv.DeviceManager.GetDevices();
                foreach (var device in _Devices) {
                    if (device.Type == DeviceType.Light) {
                        //if (device is LightBase) {
                        if (!_lightConfigs.ContainsKey(device.DeviceId))
                            _lightConfigs.Add(device.DeviceId, VisionEnv.AuroraEnv.DeviceManager.GetDeviceConfig(device.DeviceId) as LightConfig);
                    }
                }
            }
        }

        /// <summary>
        /// Light 컨피그 정보 리스트 가져오기
        /// </summary>
        /// <param name="camId">카메라 Id</param>
        /// <returns>Light Config info List</returns>
        public List<LightConfigInfo> GetLightConfigInfo(eCamId camId) {
            List<LightConfigInfo> lightConfigInfos = new List<LightConfigInfo>();
            foreach (KeyValuePair<string, LightConfig> kv in _lightConfigs) {
                if (kv.Value == null) {
                    continue;
                }

                foreach (var channelConfig in kv.Value.ChannelConfigs) {
                    if (channelConfig.CamId == camId) {
                        LightConfigInfo lightConfigInfo = new LightConfigInfo();
                        lightConfigInfo.LightId = (eLightId)Enum.Parse(typeof(eLightId), kv.Key);
                        lightConfigInfo.DimRange = (kv.Value.DimRange.Min, kv.Value.DimRange.Max);
                        lightConfigInfo.ChConfig = channelConfig.Clone();
                        lightConfigInfos.Add(lightConfigInfo);
                    }
                }
            }
            return lightConfigInfos;
        }

        /// <summary>
        /// Light 컨피그 정보 가져오기
        /// </summary>
        /// <param name="LightId">Light ID</param>
        /// <param name="Ch">채널</param>
        /// <returns></returns>
        public LightConfigInfo GetLightConfigInfo(eLightId LightId, int Ch) {
            foreach (var channelConfig in _lightConfigs[LightId.ToString()].ChannelConfigs) {
                if (channelConfig.Ch == Ch) {
                    LightConfigInfo lightConfigInfo = new LightConfigInfo();
                    lightConfigInfo.LightId = LightId;
                    lightConfigInfo.DimRange = (_lightConfigs[LightId.ToString()].DimRange.Min, _lightConfigs[LightId.ToString()].DimRange.Max);
                    lightConfigInfo.ChConfig = channelConfig.Clone();
                    return lightConfigInfo;
                }
            }
            return null;
        }
        /// <summary>
        /// Light Id 리스트 가져오기
        /// </summary>
        /// <returns>Light 리스트</returns>
        public List<string> GetLightIds() {
            List<string> LightIds = new List<string>();
            foreach (KeyValuePair<string, LightConfig> kv in _lightConfigs) {
                LightIds.Add(kv.Key);
            }

            return LightIds;
        }

        /// <summary>
        /// 조명 켜기
        /// </summary>
        /// <param name="lightId">조명 아이디</param>
        /// <param name="channel">채널 번호</param>
        /// <returns>조명 제어 결과</returns>
        public eLightResult SetOn(string lightId, int channel) {
            var res = eLightResult.OK;

            try {
                var lightDevice = VisionEnv.AuroraEnv.DeviceManager[lightId] as LightBase;
                _VisionLog.FuncI(string.Format("OnOff : {0}, Channel : {1}", true, channel));
                res = lightDevice.SetOn(channel);
            }
            catch (Exception e) {
                _VisionLog.FuncE(e.Message);
            }

            return res;
        }

        /// <summary>
        /// 조명 끄기
        /// </summary>
        /// <param name="lightId">조명 아이디</param>
        /// <param name="channel">채널 번호</param>
        /// <returns>조명 제어 결과</returns>
        public eLightResult SetOff(string lightId, int channel) {
            var res = eLightResult.OK;

            try {
                var lightDevice = VisionEnv.AuroraEnv.DeviceManager[lightId] as LightBase;
                _VisionLog.FuncI(string.Format("OnOff : {0}, Channel : {1}", false, channel));
                res = lightDevice.SetOff(channel);
            }
            catch (Exception e) {
                _VisionLog.FuncE(e.Message);
            }

            return res;
        }

        /// <summary>
        /// 조명 상태 가져오기
        /// </summary>
        /// <param name="lightId">조명 아이디</param>
        /// <param name="channel">채널 번호</param>
        /// <returns>조명 상태 (on : true, off : false)</returns>
        public bool GetOnOff(string lightId, int channel) {
            try {
                var lightDevice = VisionEnv.AuroraEnv.DeviceManager[lightId] as LightBase;
                return lightDevice.GetOnOff(channel);
            }
            catch (Exception e) {
                _VisionLog.FuncE(e.Message);
            }

            return false;
        }


        /// <summary>
        /// 라이트 레벨 설정하기 (list)
        /// </summary>
        /// <param name="lightParams">라이트 파라미터들</param>
        /// <returns></returns>
        public eLightResult SetLevels(List<LightParam> lightParams) {
            try {
                foreach (var lightParam in lightParams) {
                    SetLevel(lightParam.LightId.ToString(), lightParam.Level, lightParam.Ch);
                }
                return eLightResult.OK;
            }
            catch {
                return eLightResult.NG;
            }
        }

        /// <summary>
        /// 라이트 레벨 설정하기
        /// </summary>
        /// <param name="lightId">라이트 Id</param>
        /// <param name="chLevel">채널 레벨</param>
        /// <param name="chNum">채널 숫자</param>
        /// <returns></returns>
        public eLightResult SetLevel(string lightId, int chLevel, int chNum) {
            var lightDevice = VisionEnv.AuroraEnv.DeviceManager[lightId] as LightBase;
            _VisionLog.FuncI(string.Format("Level : {0}, Channel : {1}", chLevel, chNum));
            return lightDevice.SetLevel(chLevel, chNum);
        }

        /// <summary>
        /// 라이트 파라미터 리스트 가져오기
        /// </summary>
        /// <param name="camId">카메라 ID</param>
        /// <returns></returns>
        public List<LightParam> GetLightParams(eCamId camId) {
            List<LightParam> lightParams = new List<LightParam>();
            foreach (KeyValuePair<string, LightConfig> kv in _lightConfigs) {
                if (kv.Value == null) {
                    continue;
                }

                foreach (var channelConfig in kv.Value.ChannelConfigs) {
                    if (channelConfig.CamId == camId) {
                        LightParam lightParam = new LightParam();
                        lightParam.LightId = (eLightId)Enum.Parse(typeof(eLightId), kv.Key);
                        lightParam.Ch = channelConfig.Ch;
                        lightParam.Level = channelConfig.Level;
                        lightParam.OnOff = channelConfig.OnOff;
                        lightParams.Add(lightParam);
                    }
                }
            }
            return lightParams;
        }

        /// <summary>
        /// 라이트 컨피그 정보 저장하기
        /// </summary>
        /// <param name="lightconfigInfos">라이트 컨피그 정보들</param>
        public void SaveLightConfigInfo(List<LightConfigInfo> lightconfigInfos) {
            foreach (var lightId in _lightConfigs.Keys) {
                foreach (var lightConfigInfo in lightconfigInfos) {
                    if (lightId == lightConfigInfo.LightId.ToString()) {
                        foreach (var chConfig in _lightConfigs[lightId].ChannelConfigs) {
                            if (chConfig.Ch == lightConfigInfo.ChConfig.Ch) {
                                chConfig.Level = lightConfigInfo.ChConfig.Level;
                            }
                        }
                    }
                }
                var result = VisionEnv.AuroraEnv.DeviceManager.SaveDeviceConfig(lightId);
            }

            SetLightConfig();
        }
        /// <summary>
        /// 해제
        /// </summary>
        public void Dispose() {
        }
    }
}