using System.Data.Common;
using System.Transactions;
using FrameworkDAL.CustomCode.Role;
using FrameworkDAL.DTO.DocumentSet;
using FrameworkDAL.DTO.Project;
using FrameworkDAL.DTO.Role;
using GB5Shared.DTO.Framework.AutoNumber;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.DTO.PubSub;
using GB5Shared.DTO.Qualifier;
using GB5Shared.EntityHandler;
using GB5Shared.GB5Library.Qualifier;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.PubSub.OutBox;
using GB5Shared.Query.OutBox;
using GB5Shared.QueryExecutor;
using GB5Shared.ResponseStandard;
using GB5Shared.WorkFlow.WorkFlowEngine;
using static GB5Shared.DTO.WorkFlow.ContractsDTO;
using static GB5Shared.GB5Constant.Constant;
using static GB5Shared.GB5Constant.Constant.OUTBOXSTATUS;

namespace FrameworkBLL.Role
{
    public class RoleBLL : IRoleBLL
    {
        private readonly IRoleDAL _RoleDAL;
        private readonly AutoNumber _autoNumber;
        private readonly IWorkFlowEngine _IWorkFlowEngine;
        private readonly IQueryExecutor _queryExecutor;
        private readonly IOutBox _outBox;
        private readonly BaseEntityAppService<RoleDTO> _baseEntityAppService;


        public RoleBLL(IRoleDAL RoleDAL, AutoNumber autoNumber , IWorkFlowEngine IWorkFlowEngine , IQueryExecutor IQueryExecutor, IOutBox outBox, BaseEntityAppService<RoleDTO> _baseEntityAppService)
        {
            _RoleDAL = RoleDAL;
            _autoNumber = autoNumber;
            _IWorkFlowEngine = IWorkFlowEngine;
            _queryExecutor = IQueryExecutor;
            _outBox = outBox;
            this._baseEntityAppService = _baseEntityAppService;
        }

        public async Task<string> GetRole(int RoleId, LoginDTO LoginDTO)
        {
            try
            {
                return await _RoleDAL.GetRole(RoleId, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> SaveRole(RoleDTO roleDto, LoginDTO login)
        {
            var transaction = await _queryExecutor.BeginTransactionAsync(login);
            try
            {
                bool isNew = roleDto.RoleId == 0;

                if (isNew)
                {
                    var auto = await _autoNumber.GetNumberAsync(
                        1,
                        AUTONUMBERCONSTANT.ROLE,
                        login,
                        transaction);

                    roleDto.RoleId = auto.StartNumber;
                }

                await _baseEntityAppService.ExecuteSaveAsync(
                                    EntityConstant.OBJECTROLE,
                                    EventTypeConstant.SAVEROLEEVENTTYPEID,
                                    roleDto,
                                    login,
                                    async tx =>
                                    {
                                        var result = isNew
                                            ? await _RoleDAL.SaveRole(roleDto, login, tx)
                                            : await _RoleDAL.UpdateRole(roleDto, login, tx);

                                        return roleDto.RoleId;
                                    }, null, -1, -1, transaction);

                await _queryExecutor.CommitAsync(transaction);
                return isNew
                    ? "Details saved successfully."
                    : "Details updated successfully.";
            }
            catch (Exception)
            {
                await _queryExecutor.RollbackAsync(transaction);
                throw;
            }
        }

        //public async Task<string> SaveRole(RoleDTO RoleDTO, LoginDTO LoginDTO)
        //{
        //    var tran = await _queryExecutor.BeginTransactionAsync(LoginDTO);
        //    try
        //    {
        //        int initialId = RoleDTO.RoleId;
        //        if (initialId == 0)
        //        {
        //            AutoNumberDTO autoNumberDTO =
        //                await _autoNumber.GetNumberAsync(1, AUTONUMBERCONSTANT.ROLE, LoginDTO);

        //            RoleDTO.RoleId = autoNumberDTO.StartNumber;
        //        }

        //        // Workflow applicability check
        //        var wfResult = await _IWorkFlowEngine
        //            .CheckWorkFlowApplicability(EntityConstant.OBJECTROLE, LoginDTO);

        //        // NO WORKFLOW
        //        if (wfResult.WorkFlowMode == WORKFLOW.NONE)
        //        {
        //            RoleDTO.RoleStatus = 1; // Active

        //            if (initialId == 0)
        //                await _RoleDAL.SaveRole(RoleDTO, LoginDTO, tran);
        //            else
        //                await _RoleDAL.UpdateRole(RoleDTO, LoginDTO, tran);
        //        }
        //        else
        //        {
        //            RoleDTO.RoleStatus = 0; // Pending / In Workflow
                     
        //            if (wfResult.WorkFlowMode == WORKFLOW.WIP)
        //            {
        //                //Save Wip , Pending have to do 
        //            }
        //            else
        //            {
        //                if (initialId == 0)
        //                    await _RoleDAL.SaveRole(RoleDTO, LoginDTO, tran);
        //                else
        //                    await _RoleDAL.UpdateRole(RoleDTO, LoginDTO, tran);
        //                // Start workflow 
        //                await _IWorkFlowEngine.StartWorkflowAsync(
        //                    new StartWorkflowContext
        //                    {
        //                        EntityId = EntityConstant.OBJECTROLE,
        //                        ObjectId = RoleDTO.RoleId,
        //                        DataJson = RoleDTO
        //                    },
        //                    LoginDTO);
        //            }
        //        }
        //        await _outBox.PublishEventAsync(new OutboxDTO
        //        {
        //            ObjectTypeId = EntityConstant.OBJECTROLE,
        //            ObjectId = RoleDTO.RoleId, 
        //            Payload = RoleDTO
        //        }, LoginDTO);
        //        await _queryExecutor.CommitAsync(tran);

        //        return initialId == 0
        //            ? "Details saved successfully."
        //            : "Details updated successfully.";
        //    }
        //    catch (Exception)
        //    {
        //        await _queryExecutor.RollbackAsync(tran);
        //        throw;
        //    }
        //}


        public async Task<string> GetSelectListRole(CriteriaDTO criteriaDTO, LoginDTO loginDTO)
        {
            try
            {
                return await _RoleDAL.GetSelectListRole(criteriaDTO, loginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<Result<string>> DeleteRole(int RoleId, LoginDTO LoginDTO)
        {
            try
            {
                return await _RoleDAL.DeleteRole(RoleId, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

    }
}