using Microsoft.AspNetCore.SignalR;
using Microsoft.EntityFrameworkCore;
using Microsoft.Identity.Client.Extensions.Msal;
using System.Data;
using SystemX.Core.DB;
using SystemX.Core.Services;
using WebApi.Library.Config;
using WebApi.Library.Enums;
using WebApi.Project.UniqueKeyApi.Models;

namespace WebApi.Project.UniqueKeyApi.Services
{
    public class UniqueKeyService
    {
        private readonly IServiceScopeFactory _scopeFactory;
        private readonly ConfigService<UniqueKeyApiConfig>? _configService;

        public UniqueKeyService(IServiceProvider serviceProvider, IServiceScopeFactory scopeFactory, ConfigService<UniqueKeyApiConfig> configSerice)
        {
            _scopeFactory = scopeFactory;
            _configService = configSerice;
        }

        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 provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
                    using (var context = GetUniqueKeyDBContext(provider, 1))
                    {
                        if(context is not null)
                        {
                            var data = await context.tUniqueKeyStorages.AsNoTracking().Where(x => x.cIdentity== request.Identity).ToListAsync();
                            if (data?.Count() > 0)
                            {
                                LogXnet.WriteLine($"Exist Unique Key::{guid}", LogXLabel.Error);
                                response.Result = "Exist Unique Key";
                            }
                            else
                            {
                                var storage = new tUniqueKeyStorage
                                {
                                    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 = WebApiResult.Failed.ToString();
                                    LogXnet.WriteLine($"Transaction Error::{guid}", LogXLabel.Error);
                                }
                                else
                                {
                                    LogXnet.WriteLine($"Transaction Success", LogXLabel.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 provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
                    using(var context = GetUniqueKeyDBContext(provider, 1))
                    {
                        if (context is not null)
                        {
                            try
                            {
                                using (var transaction = await context.CreateTransactionAsync(IsolationLevel.ReadUncommitted))
                                {
                                    var data = await context.tUniqueKeyStorages.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)
                            {
                                LogXnet.WriteLine($"Select Unique Key Transaction Error::{guid}", LogXLabel.Error);
                                LogXnet.WriteLine(e);
                            }
                        }
                    }                  
                }
            }

            return response;
        }

        public async Task<List<tUniqueKeyStorage>> Request_SelectUniqueKeyAll(string guid = "")
        {
            List<tUniqueKeyStorage> result = new List<tUniqueKeyStorage>();
            using (var scope = _scopeFactory.CreateScope())
            {                
                var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
                using(var context = GetUniqueKeyDBContext(provider, 1))
                {
                    if (context is not null)
                    {
                        try
                        {
                            using (var transaction = await context.CreateTransactionAsync(IsolationLevel.ReadUncommitted))
                            {
                                result = await context.tUniqueKeyStorages.AsNoTracking().ToListAsync();
                                await context.CloseTransactionAsync(transaction);
                            }
                        }
                        catch (Exception e)
                        {
                            LogXnet.WriteLine($"Select Unique Key Transaction Error::{guid}", LogXLabel.Error);
                            LogXnet.WriteLine(e);
                        }
                    }
                }              
            }

            return result;
        }

        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 provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
                    using(var context = GetUniqueKeyDBContext(provider, 1))
                    {
                        if (context != null)
                        {
                            var selected = await context.tUniqueKeyStorages.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 = WebApiResult.Failed.ToString();
                            LogXnet.WriteLine($"Transaction Error::{guid}", LogXLabel.Error);
                        }
                        else
                        {
                            LogXnet.WriteLine($"Transaction Success", LogXLabel.DB);
                        }
                    }                   
                }
            }

            return response;
        }

        private UniqueKeyDBContext? GetUniqueKeyDBContext(DbContextProvider provider, int dbID)
        {
            var connectionString = _configService?.GetConfig()?.DataBase?.Find(x => x.DBID == dbID);
            return provider?.GetDBContext<UniqueKeyDBContext>($"{connectionString?.DBID}");
        }

    }
}