using DB.HubXDB;
using HubX.Library.Enums;
using HubX.Library.Http.Packet;
using Microsoft.EntityFrameworkCore;
using Microsoft.Identity.Client.Extensions.Msal;
using System.Data;
using SystemX.Core.DB;

namespace HubX.Server.Services
{
    public class UniqueKeyService
    {
        private readonly EFCoreService _efCoreService;

        public UniqueKeyService(EFCoreService efCoreService)
        {
            _efCoreService = efCoreService;
        }

        public async Task<Response_InsertUniqueKy> Request_InsertUniqueKey(Request_InsertUniqueKey request)
        {
            Response_InsertUniqueKy response = new Response_InsertUniqueKy();

            if (request != null)
            {
                response.Identity = request.Identity;

                var storage = new TStorage
                {
                    CIdentity = request.Identity,
                    CData1 = request.Data1,
                    CData2 = request.Data2,
                    CData3 = request.Data3,
                    CData4 = request.Data4,
                    CData5 = request.Data5,

                    CDateTime = DateTime.Now
                };

                bool transactionResult = true;
                var context = _efCoreService.GetDBContext<HubXContext>();
                if (context != null)
                {
                    using (var transaction = await context.CreateTransactionAsync())
                    {                        
                        await context.AddAsync(storage);
                        transactionResult = await context.CloseTransactionAsync(transaction);
                    }                   
                }

                //db error
                if (transactionResult == false)
                {
                    response.Result = EnumResult.Failed.ToString();
                    Log4net.WriteLine($"Transaction Error", LogType.Error);
                }
                else
                {
                    Log4net.WriteLine($"Transaction Success", LogType.DB);
                }
            }

            return response;
        }

        public async Task<Response_SelectUniqueKy> Request_SelectUniqueKey(Request_SelectUniqueKey request)
        {
            Response_SelectUniqueKy response = new Response_SelectUniqueKy();

            if (request != null)
            {
                response.Identity = request.Identity;

                var context = _efCoreService.GetDBContext<HubXContext>();
                if (context != null)
                {                
                    try
                    {
                        using (var transaction = await context.CreateTransactionAsync(IsolationLevel.ReadUncommitted))
                        {
                            var data = context.TStorages.AsNoTracking().First(x=>x.CIdentity == request.Identity);
                            await context.CloseTransactionAsync(transaction);
                            if(data != null)
                            {
                                response.Data1 = data.CData1;
                                response.Data2 = data.CData2;
                                response.Data3 = data.CData3;
                                response.Data4 = data.CData4;
                                response.Data5 = data.CData5;
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Log4net.WriteLine($"Select Unique Key Transaction Error", LogType.Error);
                        Log4net.WriteLine(e);
                    }                   
                }
            }

            return response;
        }
    }
}