#region copyright
//------------------------------------------------------------------------------
//  此代码版权声明为全文件覆盖，如有原作者特别声明，会在下方手动补充
//  此代码版权（除特别声明外的代码）归作者本人Diego所有
//  源代码使用协议遵循本仓库的开源协议及附加协议
//  Gitee源代码仓库：https://gitee.com/diego2098/ThingsGateway
//  Github源代码仓库：https://github.com/kimdiego2098/ThingsGateway
//  使用文档：https://diego2098.gitee.io/thingsgateway-docs/
//  QQ群：605534569
//------------------------------------------------------------------------------
#endregion

using Furion;

using Mapster;

using Newtonsoft.Json.Linq;

using Opc.Ua;
using Opc.Ua.Server;

using System;
using System.Collections.Generic;
using System.Linq;

using ThingsGateway.Application;
using ThingsGateway.Application.Extensions;
using ThingsGateway.Foundation;
using ThingsGateway.Foundation.Adapter.OPCUA;

using TouchSocket.Core;

namespace ThingsGateway.OPCUA;


/// <summary>
/// 数据节点
/// </summary>
public class ThingsGatewayNodeManager : CustomNodeManager2
{
    private const string ReferenceServer = "https://diego2098.gitee.io/thingsgateway-docs/";
    private readonly TypeAdapterConfig _config;
    private readonly UploadDevice _device;
    private readonly GlobalDeviceData _globalDeviceData;
    private readonly RpcSingletonService _rpcCore;
    private readonly ILog LogMessage;
    /// <summary>
    /// OPC和网关对应表
    /// </summary>
    private readonly Dictionary<NodeId, OPCUATag> NodeIdTags = new();
    /// <inheritdoc cref="ThingsGatewayNodeManager"/>
    public ThingsGatewayNodeManager(UploadDevice device, ILog log, IServerInternal server, ApplicationConfiguration configuration) : base(server, configuration, ReferenceServer)
    {
        _device = device;
        LogMessage = log;
        _rpcCore = App.GetService<RpcSingletonService>();
        _globalDeviceData = App.GetService<GlobalDeviceData>();
        _config = new TypeAdapterConfig();
        _config.ForType<HistoryValue, DataValue>()
.Map(dest => dest.WrappedValue, (src) => new Variant(src.Value))
.Map(dest => dest.SourceTimestamp, src => DateTime.SpecifyKind(src.CollectTime, DateTimeKind.Utc))
.Map(dest => dest.StatusCode, (src) =>
src.IsOnline ? StatusCodes.Good : StatusCodes.Bad);
    }



    /// <summary>
    /// 创建服务目录结构
    /// </summary>
    /// <param name="externalReferences"></param>
    public override void CreateAddressSpace(IDictionary<NodeId, IList<IReference>> externalReferences)
    {
        lock (Lock)
        {
            if (!externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out IList<IReference> references))
            {
                externalReferences[ObjectIds.ObjectsFolder] = references = new List<IReference>();
            }
            //首节点
            FolderState rootFolder = CreateFolder(null, "ThingsGateway", "ThingsGateway");
            rootFolder.AddReference(ReferenceTypes.Organizes, true, ObjectIds.ObjectsFolder);
            references.Add(new NodeStateReference(ReferenceTypes.Organizes, false, rootFolder.NodeId));
            rootFolder.EventNotifier = EventNotifiers.SubscribeToEvents;
            AddRootNotifier(rootFolder);

            //创建设备树
            var _geviceGroup = _globalDeviceData.CollectDevices.ToList().Adapt<List<CollectDevice>>().GetTree();
            // 开始寻找设备信息，并计算一些节点信息
            foreach (var item in _geviceGroup)
            {
                //设备树会有两层
                FolderState fs = CreateFolder(rootFolder, item.Name, item.Name);
                fs.AddReference(ReferenceTypes.Organizes, true, ObjectIds.ObjectsFolder);
                fs.EventNotifier = EventNotifiers.SubscribeToEvents;
                if (item.Childrens?.Count > 0)
                {
                    foreach (var item2 in item.Childrens)
                    {
                        AddTagNode(fs, item2.Name);
                    }
                }
                else
                {
                    AddTagNode(fs, item.Name);
                }

            }
            FolderState memoryfs = CreateFolder(null, "ThingsGateway中间变量", "ThingsGateway中间变量");
            var variableRunTimes = _globalDeviceData.MemoryVariables;
            foreach (var item in variableRunTimes)
            {
                CreateVariable(memoryfs, item);
            }
            AddPredefinedNode(SystemContext, rootFolder);

        }

    }
    /// <summary>
    /// 获取变量的属性值
    /// </summary>
    public string GetPropertyValue(DeviceVariableRunTime variableRunTime, string propertyName)
    {
        if (variableRunTime.VariablePropertys.ContainsKey(_device.Id))
        {
            var data = variableRunTime.VariablePropertys[_device.Id].FirstOrDefault(a =>
                  a.PropertyName == propertyName);
            if (data != null)
            {
                return data.Value;
            }
        }
        return null;
    }

    /// <summary>
    /// 读取历史数据
    /// </summary>
    public override void HistoryRead(OperationContext context,
        HistoryReadDetails details,
        TimestampsToReturn timestampsToReturn,
        bool releaseContinuationPoints,
        IList<HistoryReadValueId> nodesToRead,
        IList<HistoryReadResult> results,
        IList<ServiceResult> errors)
    {
        base.HistoryRead(context, details, timestampsToReturn, releaseContinuationPoints, nodesToRead, results, errors);
        //必须带有时间范围
        if (details is not ReadRawModifiedDetails readDetail || readDetail.StartTime == DateTime.MinValue || readDetail.EndTime == DateTime.MinValue)
        {
            errors[0] = StatusCodes.BadHistoryOperationUnsupported;
            return;
        }
        var service = ServiceHelper.GetBackgroundService<HistoryValueWorker>();
        if (!service.StatuString.IsSuccess)
        {
            errors[0] = StatusCodes.BadHistoryOperationUnsupported;
            return;
        }

        var db = service.GetHisDbAsync().GetAwaiter().GetResult();
        if (!db.IsSuccess)
        {
            errors[0] = StatusCodes.BadHistoryOperationUnsupported;
            return;
        }
        var startTime = readDetail.StartTime;
        var endTime = readDetail.EndTime;

        for (int i = 0; i < nodesToRead.Count; i++)
        {
            var historyRead = nodesToRead[i];
            if (NodeIdTags.TryGetValue(historyRead.NodeId, out OPCUATag tag))
            {
                var data = db.Content.Queryable<HistoryValue>()
                    .Where(a => a.Name == tag.SymbolicName)
                    .Where(a => a.CollectTime >= startTime)
                    .Where(a => a.CollectTime <= endTime)
                    .ToList();

                if (data.Count > 0)
                {

                    var hisDataValue = data.Adapt<List<DataValue>>(_config);
                    HistoryData hisData = new();
                    hisData.DataValues.AddRange(hisDataValue);
                    errors[i] = StatusCodes.Good;
                    //切记Processed设为true，否则客户端会报错
                    historyRead.Processed = true;
                    results[i] = new HistoryReadResult()
                    {
                        StatusCode = StatusCodes.Good,
                        HistoryData = new ExtensionObject(hisData)
                    };
                }
                else
                {
                    results[i] = new HistoryReadResult()
                    {
                        StatusCode = StatusCodes.GoodNoData
                    };
                }
            }
            else
            {
                results[i] = new HistoryReadResult()
                {
                    StatusCode = StatusCodes.BadNotFound
                };
            }
        }
    }

    /// <inheritdoc/>
    public override NodeId New(ISystemContext context, NodeState node)
    {
        if (node is BaseInstanceState instance && instance.Parent != null)
        {
            string id = instance.Parent.NodeId.Identifier?.ToString();
            if (id != null)
            {
                //用下划线分割
                return new NodeId(id + "_" + instance.SymbolicName, instance.Parent.NodeId.NamespaceIndex);
            }
        }
        return node.NodeId;
    }

    /// <summary>
    /// 更新变量
    /// </summary>
    /// <param name="variable"></param>
    public void UpVariable(VariableData variable)
    {
        var uaTag = NodeIdTags.Values.FirstOrDefault(it => it.SymbolicName == variable.Name);
        if (uaTag == null) return;
        object initialItemValue = null;
        initialItemValue = variable.Value;
        if (initialItemValue != null)
        {
            var code = variable.IsOnline ? StatusCodes.Good : StatusCodes.Bad;
            if (code == StatusCodes.Good)
            {
                ChangeNodeData(uaTag, initialItemValue, variable.ChangeTime);
            }

            if (uaTag.StatusCode != code)
            {
                uaTag.StatusCode = code;
            }
            uaTag.ClearChangeMasks(SystemContext, false);

        }
    }

    /// <summary>
    /// <inheritdoc/>
    /// </summary>
    /// <param name="disposing"></param>
    protected override void Dispose(bool disposing)
    {
        NodeIdTags.Clear();
        base.Dispose(disposing);
    }
    private static NodeId DataNodeType(Type tp)
    {
        if (tp == typeof(bool))
            return DataTypeIds.Boolean;
        if (tp == typeof(byte))
            return DataTypeIds.Byte;
        if (tp == typeof(sbyte))
            return DataTypeIds.SByte;
        if (tp == typeof(short))
            return DataTypeIds.Int16;
        if (tp == typeof(ushort))
            return DataTypeIds.UInt16;
        if (tp == typeof(int))
            return DataTypeIds.Int32;
        if (tp == typeof(uint))
            return DataTypeIds.UInt32;
        if (tp == typeof(long))
            return DataTypeIds.Int64;
        if (tp == typeof(ulong))
            return DataTypeIds.UInt64;
        if (tp == typeof(float))
            return DataTypeIds.Float;
        if (tp == typeof(double))
            return DataTypeIds.Double;
        if (tp == typeof(string))
            return DataTypeIds.String;
        if (tp == typeof(DateTime))
            return DataTypeIds.DateTime;
        return DataTypeIds.String;
    }

    /// <summary>
    /// 添加变量节点
    /// </summary>
    /// <param name="fs">设备组节点</param>
    /// <param name="name">设备名称</param>
    private void AddTagNode(FolderState fs, string name)
    {
        var device = _globalDeviceData.CollectDevices.Where(a => a.Name == name).FirstOrDefault();
        if (device != null)
        {
            foreach (var item in device.DeviceVariableRunTimes)
            {
                CreateVariable(fs, item);
            }
        }
    }

    /// <summary>
    /// 在服务器端直接更改对应数据节点的值
    /// </summary>
    private void ChangeNodeData(OPCUATag tag, object value, DateTime dateTime)
    {
        object newValue;
        try
        {
            if (!tag.IsDataTypeInit)
            {
                if (tag.DataType == DataTypeIds.String)
                {
                    if (value != null)
                    {
                        SetDataType(tag, value);
                    }
                }
                else
                {
                    SetRank(tag, value);
                }
            }
            var jToken = JToken.FromObject((tag.DataType == DataTypeIds.String ? value?.ToString() : value));
            var dataValue = JsonUtils.DecoderObject(
               this.Server.MessageContext,
           tag.DataType,
                TypeInfo.GetBuiltInType(tag.DataType, this.SystemContext.TypeTable),
                jToken.CalculateActualValueRank(),
                jToken
                );
            newValue = dataValue;
        }
        catch (Exception ex)
        {
            LogMessage.LogWarning(ex, "转化值错误");
            newValue = value;
        }
        tag.Value = newValue;
        tag.Timestamp = dateTime;


        void SetDataType(OPCUATag tag, object value)
        {
            tag.IsDataTypeInit = true;
            var tp = value.GetType();
            if (tp == typeof(JArray))
            {
                try
                {
                    tp = ((JValue)((JArray)value).FirstOrDefault()).Value.GetType();
                    tag.ValueRank = ValueRanks.OneOrMoreDimensions;
                }
                catch
                {
                }
            }
            if (tp == typeof(JValue))
            {
                tp = ((JValue)value).Value.GetType();
                tag.ValueRank = ValueRanks.Scalar;
            }
            tag.DataType = DataNodeType(tp);

            tag.ClearChangeMasks(SystemContext, false);
        }

        void SetRank(OPCUATag tag, object value)
        {
            tag.IsDataTypeInit = true;
            var tp = value.GetType();
            if (tp == typeof(JArray))
            {
                try
                {
                    tp = ((JValue)((JArray)value).FirstOrDefault()).Value.GetType();
                    tag.ValueRank = ValueRanks.OneOrMoreDimensions;
                }
                catch
                {
                }
            }
            tag.ClearChangeMasks(SystemContext, false);
        }
    }

    /// <summary>
    /// 创建文件夹
    /// </summary>
    private FolderState CreateFolder(NodeState parent, string name, string description)
    {
        FolderState folder = new(parent)
        {
            SymbolicName = name,
            ReferenceTypeId = ReferenceTypes.Organizes,
            TypeDefinitionId = ObjectTypeIds.FolderType,
            Description = description,
            NodeId = new NodeId(name, NamespaceIndex),
            BrowseName = new QualifiedName(name, NamespaceIndex),
            DisplayName = new LocalizedText(name),
            WriteMask = AttributeWriteMask.None,
            UserWriteMask = AttributeWriteMask.None,
            EventNotifier = EventNotifiers.None
        };

        parent?.AddChild(folder);

        return folder;
    }

    /// <summary>
    /// 创建一个值节点，类型需要在创建的时候指定
    /// </summary>
    private OPCUATag CreateVariable(NodeState parent, DeviceVariableRunTime variableRunTime)
    {
        OPCUATag variable = new(parent)
        {
            SymbolicName = variableRunTime.Name,
            ReferenceTypeId = ReferenceTypes.Organizes,
            TypeDefinitionId = VariableTypeIds.BaseDataVariableType,
            NodeId = new NodeId(variableRunTime.Name, NamespaceIndex),
            Description = variableRunTime.Description,
            BrowseName = new QualifiedName(variableRunTime.Name, NamespaceIndex),
            DisplayName = new LocalizedText(variableRunTime.Name),
            WriteMask = AttributeWriteMask.DisplayName | AttributeWriteMask.Description,
            UserWriteMask = AttributeWriteMask.DisplayName | AttributeWriteMask.Description,
            ValueRank = ValueRanks.Scalar,
            Id = variableRunTime.Id,
            DataType = DataNodeType(variableRunTime)
        };
        var level = ProtectTypeTrans(variableRunTime);
        variable.AccessLevel = level;
        variable.UserAccessLevel = level;
        variable.Historizing = variableRunTime.HisEnable;
        variable.Value = Opc.Ua.TypeInfo.GetDefaultValue(variable.DataType, ValueRanks.Any, Server.TypeTree);
        var code = variableRunTime.IsOnline ? StatusCodes.Good : StatusCodes.Bad;
        variable.StatusCode = code;
        variable.Timestamp = variableRunTime.CollectTime;
        variable.OnWriteValue = OnWriteDataValue;
        parent?.AddChild(variable);
        NodeIdTags.AddOrUpdate(variable.NodeId, variable);
        return variable;
    }
    /// <summary>
    /// 网关转OPC数据类型
    /// </summary>
    /// <param name="variableRunTime"></param>
    /// <returns></returns>
    private NodeId DataNodeType(DeviceVariableRunTime variableRunTime)
    {
        var str = GetPropertyValue(variableRunTime, nameof(OPCUAServerVariableProperty.DataTypeEnum));
        Type tp;
        if (Enum.TryParse<DataTypeEnum>(str, out DataTypeEnum result))
        {
            tp = result.GetSystemType();
        }
        else
        {
            tp = variableRunTime.DataType;
        }

        return DataNodeType(tp);
    }
    private ServiceResult OnWriteDataValue(ISystemContext context, NodeState node, NumericRange indexRange, QualifiedName dataEncoding, ref object value, ref StatusCode statusCode, ref DateTime timestamp)
    {
        try
        {
            var context1 = context as ServerSystemContext;
            if (context1.UserIdentity.TokenType == UserTokenType.Anonymous)
            {
                return StatusCodes.BadUserAccessDenied;
            }
            OPCUATag variable = node as OPCUATag;
            if (NodeIdTags.TryGetValue(variable.NodeId, out OPCUATag tag))
            {
                if (StatusCode.IsGood(variable.StatusCode))
                {
                    //仅当指定了值时才将值写入
                    if (variable.Value != null)
                    {

                        var result = _rpcCore.InvokeDeviceMethodAsync("OPCUASERVER-" + context1?.OperationContext?.Session?.Identity?.DisplayName,
                            new()
                            {
                                { variable.SymbolicName, value?.ToString() }
                            }


                            ).ConfigureAwait(true).GetAwaiter().GetResult();
                        if (result.Values.FirstOrDefault().IsSuccess)
                        {
                            return StatusCodes.Good;
                        }
                        else
                        {
                            return new(StatusCodes.BadWaitingForResponse, result.Values.FirstOrDefault().Message);
                        }
                    }
                }

            }
            return StatusCodes.BadWaitingForResponse;
        }
        catch
        {
            return StatusCodes.BadTypeMismatch;
        }

    }

    private byte ProtectTypeTrans(DeviceVariableRunTime variableRunTime)
    {
        byte result = 0;
        result = variableRunTime.ProtectTypeEnum switch
        {
            ProtectTypeEnum.ReadOnly => (byte)(result | AccessLevels.CurrentRead),
            ProtectTypeEnum.ReadWrite => (byte)(result | AccessLevels.CurrentReadOrWrite),
            _ => (byte)(result | AccessLevels.CurrentRead),
        };
        if (variableRunTime.HisEnable)
        {
            result = (byte)(result | AccessLevels.HistoryRead);
        }
        return result;
    }

}