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

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

        public UniqueKeyService(EFCoreService efCoreService, IServiceScopeFactory scopeFactory)
        {
            _efCoreService = efCoreService;
            _scopeFactory = scopeFactory;
        }

        public async Task<Response_InsertUniqueKy> Request_InsertUniqueKey(Request_InsertUniqueKey request, string guid = "")
        {
            Response_InsertUniqueKy response = new Response_InsertUniqueKy();

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

                bool transactionResult = true;                      
                using (var scope = _scopeFactory.CreateScope())
                {
                    var context = scope.ServiceProvider.GetRequiredService<HubXContext>();
                    if (context != null)
                    {
                        var data = await context.TStorages.AsNoTracking().Where(x => x.CIdentity == request.Identity).ToListAsync();
                        if (data?.Count() > 0)
                        {
                            Log4net.WriteLine($"Exist Unique Key::{guid}", LogType.Error);
                            response.Result = "Exist Unique Key";
                        }
                        else
                        {
                            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
                            };                
                            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::{guid}", LogType.Error);
                            }
                            else
                            {
                                Log4net.WriteLine($"Transaction Success", LogType.DB);
                            }
                        }
                    }
                }                                   
            }

            return response;
        }

        public async Task<Response_SelectUniqueKy> Request_SelectUniqueKey(Request_SelectUniqueKey request, string guid = "")
        {
            Response_SelectUniqueKy response = new Response_SelectUniqueKy();

            if (request != null)
            {
                response.Identity = request.Identity;
                using (var scope = _scopeFactory.CreateScope())
                {
                    var context = scope.ServiceProvider.GetRequiredService<HubXContext>();
                    if (context != null)
                    {
                        try
                        {
                            using (var transaction = await context.CreateTransactionAsync(IsolationLevel.ReadUncommitted))
                            {
                                var data = await context.TStorages.AsNoTracking().FirstOrDefaultAsync(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::{guid}", LogType.Error);
                            Log4net.WriteLine(e);
                        }
                    }
                }
            }

            return response;
        }

        public async Task<Response_UpdateUniqueKy> Request_UpdateUniqueKey(Request_UpdateUniqueKey request, string guid = "")
        {
            Response_UpdateUniqueKy response = new Response_UpdateUniqueKy();

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

                using (var scope = _scopeFactory.CreateScope())
                {
                    var context = scope.ServiceProvider.GetRequiredService<HubXContext>();
                    if (context != null)
                    {
                        var selected = await context.TStorages.FirstOrDefaultAsync(x => x.CIdentity == request.Identity);
                        if (selected != null)
                        {
                            selected.CData1 = request.Data1;
                            selected.CData2 = request.Data2;
                            selected.CData3 = request.Data3;
                            selected.CData4 = request.Data4;
                            selected.CData5 = request.Data5;

                            using (var transaction = await context.CreateTransactionAsync())
                            {
                                context.Update(selected);
                                transactionResult = await context.CloseTransactionAsync(transaction);
                            }
                        }
                    }

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

            return response;
        }
    }
}