using System.Drawing;
using DispenserHal.Camera.DTO;
using DispenserHal.Camera.Enum;
using DispenserHal.Camera.VO;
using Serilog;

namespace DispenserHal.Camera.Interface;

public abstract class AbstractCamera : ICamera
{
    public Dictionary<string, bool> BoolParam = new();
    private readonly long defaultTimeout = 10000;
    public Dictionary<string, double> DoubleParam = new();
    public Dictionary<string, string> EnumParam = new();
    public Dictionary<string, float> FloatParam = new();


    public Dictionary<string, int> IntParam = new();
    public Dictionary<string, long> LongParam = new();
    public Dictionary<string, string> StringParam = new();

    protected AbstractCamera(string sn, Dictionary<ParamTypeEnum, string> paramMap)
    {
        SN = sn;
        ParseParam(paramMap);
    }

    private bool isConnected => Connected;
    private bool isStart => Started;
    public string SN { get; }

    public bool CapturingVideo { get; set; }

    protected Action<string, Bitmap> Callback { get; private set; }

    public bool Connected { get; set; }
    public bool Started { get; set; }

    public CameraResponseVO Connect()
    {
        return Connect(defaultTimeout);
    }

    public CameraResponseVO Connect(long timeout)
    {
        if (isConnected) return CameraResponseVO.OfFailed("相机已经连接");

        var resp = DoConnect(timeout);
        if (resp.IsSuccess()) MarkConnect(true);

        return resp;
    }


    public CameraResponseVO Close()
    {
        if (!isConnected) return CameraResponseVO.OfFailed($"{SN}已关闭");

        var resp = DoClose();
        if (resp.IsSuccess()) MarkConnect(false);

        return resp;
    }


    public CameraResponseVO RegisterCallback(Action<string, Bitmap> callback)
    {
        Callback = callback;
        return CameraResponseVO.OfSuccess("注册回调函数成功");
    }


    public CameraResponseVO StartSteaming()
    {
        if (!isConnected) return CameraResponseVO.OfFailed($"{SN}未连接");

        if (isStart) return CameraResponseVO.OfFailed($"{SN}已开启采集");

        var resp = DoStartSteaming();
        if (resp.IsSuccess()) MarkStarted(true);

        return resp;
    }

    public CameraResponseVO TokePhoto()
    {
        if (!isConnected)
        {
            Log.Error($"{SN}未连接");
            return CameraResponseVO.OfFailed($"{SN}未连接");
        }

        return DoTokePhoto();
    }

    public CameraResponseVO StartCaptureVideo()
    {
        if (!isConnected)
        {
            Log.Error($"{SN}未连接");
            return CameraResponseVO.OfFailed($"{SN}未连接");
        }

        return DoStartCaptureVideo();
    }

    public CameraResponseVO StopCaptureVideo()
    {
        if (!isConnected)
        {
            Log.Error($"{SN}未连接");
            return CameraResponseVO.OfFailed($"{SN}未连接");
        }

        return DoStopCaptureVideo();
    }

    public abstract CameraResponseVO SwitchHardTriggerMode();


    public CameraResponseVO StopSteaming()
    {
        if (!isConnected) return CameraResponseVO.OfFailed($"{SN}未连接");

        if (!isStart) return CameraResponseVO.OfFailed($"{SN}已关闭采集");

        var resp = DoStopSteaming();
        if (resp.IsSuccess()) MarkStarted(false);

        return resp;
    }

    public abstract CameraResponseVO SwitchContinuousMode();
    public abstract CameraResponseVO SwitchSoftwareTriggerMode();
    public abstract CameraResponseVO SoftwareTrigger();

    public abstract CameraResponseVO SetEnumValue(string name, uint value);
    public abstract CameraResponseVO SetIntValue(string strKey, long nvalue);
    public abstract CameraResponseVO SetBoolValue(string strKey, bool nvalue);
    public abstract CameraResponseVO SetFloatValue(string strKey, float nvalue);

    public abstract bool GetBoolValue(string key);

    public abstract EnumValue? GetEnumValue(string key);
    public abstract FloatValue? GetFloatValue(string key);
    public abstract IntValue GetIntValue(string key);
    public abstract StringValue? GetStringValue(string key);

    public abstract EnumItem GetEnumEntrySymbolic(string key, uint supportIndex);

    protected void MarkConnect(bool value)
    {
        Connected = value;
    }

    protected void MarkStarted(bool value)
    {
        Started = value;
    }

    private void ParseParam(Dictionary<ParamTypeEnum, string> paramMap)
    {
        if (paramMap == null || !paramMap.Any()) return;

        foreach (var key in paramMap.Keys) DoParseParam(key, paramMap[key]);
    }

    private void DoParseParam(ParamTypeEnum key, string value)
    {
        if (string.IsNullOrEmpty(value)) return;

        var keyPairs = value.Split(',');
        foreach (var kp in keyPairs)
        {
            var kvArr = kp.Split(':');
            if (kvArr.Length == 2)
                switch (key)
                {
                    case ParamTypeEnum.INT:
                        IntParam[kvArr[0]] = int.Parse(kvArr[1]);
                        break;
                    case ParamTypeEnum.LONG:
                        LongParam[kvArr[0]] = long.Parse(kvArr[1]);
                        break;
                    case ParamTypeEnum.DOUBLE:
                        DoubleParam[kvArr[0]] = double.Parse(kvArr[1]);
                        break;
                    case ParamTypeEnum.FLOAT:
                        FloatParam[kvArr[0]] = float.Parse(kvArr[1]);
                        break;
                    case ParamTypeEnum.STRING:
                        StringParam[kvArr[0]] = kvArr[1];
                        break;
                    case ParamTypeEnum.BOOL:
                        BoolParam[kvArr[0]] = bool.Parse(kvArr[1]);
                        break;
                    case ParamTypeEnum.ENUM:
                        EnumParam[kvArr[0]] = kvArr[1];
                        break;
                }
        }
    }

    protected abstract CameraResponseVO DoClose();
    protected abstract CameraResponseVO DoConnect(long timeout);
    protected abstract CameraResponseVO DoStartSteaming();
    protected abstract CameraResponseVO DoStopSteaming();
    protected abstract CameraResponseVO DoTokePhoto();

    protected abstract CameraResponseVO DoStartCaptureVideo();

    protected abstract CameraResponseVO DoStopCaptureVideo();
}