package id.co.sofcograha.gajiidapi.domain.hris.mst.payrollGroup.services;

import id.co.sofcograha.gajiidapi.base.extendables.FreeFormService;
import id.co.sofcograha.gajiidapi.base.mst.company.entities.Company;
import id.co.sofcograha.gajiidapi.base.mst.company.services.CompanyService;
import id.co.sofcograha.gajiidapi.base.mst.user.entities.User;
import id.co.sofcograha.gajiidapi.base.mst.user.services.UserLoginService;
import id.co.sofcograha.gajiidapi.base.mst.user.services.UserService;
import id.co.sofcograha.gajiidapi.base.mst.usercompany.entities.UserCompany;
import id.co.sofcograha.gajiidapi.base.mst.usercompany.services.UserCompanyLoginService;
import id.co.sofcograha.gajiidapi.base.mst.usercompany.services.UserCompanyService;
import id.co.sofcograha.gajiidapi.base.utils.VersionUtil;
import id.co.sofcograha.gajiidapi.domain.hris.mst.payrollGroup.entities.PayrollGroup;
import id.co.sofcograha.gajiidapi.domain.hris.mst.userPayrollGroupAuthorization.entities.UserPayrollGroupAuthorization;
import id.co.sofcograha.gajiidapi.domain.hris.mst.userPayrollGroupAuthorization.services.UserPayrollGroupAuthorizationService;

import java.util.Date;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class PayrollGroupAuthorizationService extends FreeFormService {

    @Autowired private CompanyService companyService;
    @Autowired private UserCompanyLoginService userCompanyLoginService;
    @Autowired private PayrollGroupService payrollGroupService;
    @Autowired private UserLoginService userLoginService;
    @Autowired private UserService userService;
    @Autowired private UserCompanyService userCompanyService;
    @Autowired private UserPayrollGroupAuthorizationService userPayrollGroupAuthorizationService;

//  @Transactional
//  public PayrollGroup add(User user, Date startDate, PayrollGroup payrollGroup, Company company) {
//      valUserRequired(user);
//      valRequiredDate(startDate, "userPayrollGroupAuthorization.startDate.required");
//      valPayrollGroupRequired(payrollGroup);
//      valCompanyRequired(company);
//      throwBatchError();
//
//      valCompanyIdVersionRequired(company.getId(), company.getVersion());
//      throwBatchError();
//
//      valCompanyEntityExists(company.getId());
//      throwBatchError();
//
//      valCompanyEntityActive(company.getId());
//      throwBatchError();
//
//      valCompanyVersion(company.getId(), company.getVersion());
//      throwBatchError();
//
//      addUserPayrollGroupAuthorization(user, startDate, payrollGroup, company);
//      return payrollGroup;
//  }

    @Transactional
    public UserPayrollGroupAuthorization add(UserPayrollGroupAuthorization userPayrollGroupAuthorization) {
        UserCompany userCompany = userCompanyLoginService.getCurrentUserCompany();

        valRequiredUserPayrollGroupAuthorization(userPayrollGroupAuthorization);
        valCompanyRequired(userCompany.getCompany());
        throwBatchError();

        valRequiredDate(userPayrollGroupAuthorization.getStartDate(), "userPayrollGroupAuthorization.endDate.required");
        throwBatchError();

        valCompanyEntityExists(userCompany.getCompany().getId());
        throwBatchError();

        userPayrollGroupAuthorization = addUserPayrollGroupAuthorization(userPayrollGroupAuthorization, userCompany.getCompany());
        return userPayrollGroupAuthorization;
    }

    @Transactional
    public void delete(User user, Date startDate, Date endDate, PayrollGroup payrollGroup, Company company) {
        valUserRequired(user);
        valRequiredDate(startDate, "userPayrollGroupAuthorization.startDate.required");
        valRequiredDate(endDate, "userPayrollGroupAuthorization.endDate.required");
        valPayrollGroupRequired(payrollGroup);
        valCompanyRequired(company);
        throwBatchError();

        valUserIdVersionRequired(user.getId(), user.getVersion());
        valPayrollIdVersionRequired(payrollGroup.getId(), payrollGroup.getVersion());
        valCompanyIdVersionRequired(company.getId(), company.getVersion());
        throwBatchError();

        valUserEntityExists(user.getId());
        valPayrollGroupEntityExists(payrollGroup.getId());
        valCompanyEntityExists(company.getId());
        throwBatchError();

        valCompanyEntityActive(company.getId());
        throwBatchError();

        valCompanyVersion(company.getId(), company.getVersion());
        throwBatchError();

        deleteUserPayrollGroupAuthorization(user, startDate, endDate, payrollGroup, company);
    }

    private UserPayrollGroupAuthorization addUserPayrollGroupAuthorization(UserPayrollGroupAuthorization userPayrollGroupAuthorization, Company company) {
        userPayrollGroupAuthorization = userPayrollGroupAuthorizationService.add(userPayrollGroupAuthorization);
        addSuperUserPayrollGroupAuthorization(userPayrollGroupAuthorization, company);
        return userPayrollGroupAuthorization;
    }

    private void addSuperUserPayrollGroupAuthorization(UserPayrollGroupAuthorization userPayrollGroupAuthorization, Company company) {
        Boolean isSuperUser = true;
        List<UserCompany> userCompanies = userCompanyService.getSuperUserByCompany(company, isSuperUser).orElse(null);
        if (userCompanies != null) {
            for (UserCompany userCompany: userCompanies) {
                UserPayrollGroupAuthorization existUserPayrollGroupAuthorization = userPayrollGroupAuthorizationService.findByBk(userCompany.getUser(), userPayrollGroupAuthorization.getStartDate(), userPayrollGroupAuthorization.getPayrollGroup()).orElse(null);
                if (existUserPayrollGroupAuthorization == null) {
                    UserPayrollGroupAuthorization superUserPayrollGroupAuthorization = new UserPayrollGroupAuthorization();
                    superUserPayrollGroupAuthorization.setUser(userCompany.getUser());
                    superUserPayrollGroupAuthorization.setStartDate(userPayrollGroupAuthorization.getStartDate());
                    superUserPayrollGroupAuthorization.setEndDate(null);
                    superUserPayrollGroupAuthorization.setPayrollGroup(userPayrollGroupAuthorization.getPayrollGroup());

                    userPayrollGroupAuthorizationService.add(superUserPayrollGroupAuthorization);
                }
            }
        }
    }

//  private void addUserPayrollGroupAuthorization(User user, Date startDate, PayrollGroup payrollGroup, Company company) {
//      UserPayrollGroupAuthorization userPayrollGroupAuthorization = new UserPayrollGroupAuthorization();
//      userPayrollGroupAuthorization.setUser(user);
//      userPayrollGroupAuthorization.setStartDate(startDate);
//      userPayrollGroupAuthorization.setEndDate(null);
//      userPayrollGroupAuthorization.setPayrollGroup(payrollGroup);
//      userPayrollGroupAuthorizationService.add(userPayrollGroupAuthorization);
//
//      addSuperUserPayrollGroupAuthorization(user, startDate, payrollGroup, company);
//  }

//  private void addSuperUserPayrollGroupAuthorization(User user, Date startDate, PayrollGroup payrollGroup, Company company) {
//      Boolean isSuperUser = true;
//      List<UserCompany> userCompanies = userCompanyService.getSuperUserByCompany(company, isSuperUser).orElse(null);
//      if (userCompanies != null) {
//          for (UserCompany userCompany: userCompanies) {
//              UserPayrollGroupAuthorization existUserPayrollGroupAuthorization = userPayrollGroupAuthorizationService.findByBk(userCompany.getUser(), startDate, payrollGroup).orElse(null);
//              if (existUserPayrollGroupAuthorization == null) {
//                  UserPayrollGroupAuthorization userPayrollGroupAuthorization = new UserPayrollGroupAuthorization();
//                  userPayrollGroupAuthorization.setUser(userCompany.getUser());
//                  userPayrollGroupAuthorization.setStartDate(startDate);
//                  userPayrollGroupAuthorization.setEndDate(null);
//                  userPayrollGroupAuthorization.setPayrollGroup(payrollGroup);
//
//                  userPayrollGroupAuthorizationService.add(userPayrollGroupAuthorization);
//              }
//          }
//      }
//  }

    private void deleteUserPayrollGroupAuthorization(User user, Date startDate, Date endDate, PayrollGroup payrollGroup, Company company) {
        User currentUser = userLoginService.getUserInfo();
        UserCompany userCompany = userCompanyService.findByBk(user, company).orElse(null);
        UserPayrollGroupAuthorization entity = userPayrollGroupAuthorizationService.findByBk(user, startDate, payrollGroup).orElse(null);
        entity.setEndDate(endDate);

        if (userCompany.isSuperUser() == true) {
            if (userCompany.getUser().getId() == currentUser.getId()) {
                userPayrollGroupAuthorizationService.edit(entity);
            } else {
                error("userPayrollGroupAuthorization.not.delete.superuser");
            }
        } else {
            userPayrollGroupAuthorizationService.edit(entity);
        }
    }

    private void valRequiredUserPayrollGroupAuthorization(UserPayrollGroupAuthorization userPayrollGroupAuthorization) {
        if (userPayrollGroupAuthorization == null) {
            batchError("userPayrollGroupAuthorization.required");
        }
    }

    private void valUserRequired(User user) {
        if (user == null) {
            batchError("userPayrollGroupAuthorization.user.required");
        }
    }

    private void valUserIdVersionRequired(String id, Long version) {
        if (id == null || version == null) {
            batchError("userPayrollGroupAuthorization.user.required");
        }
    }

    private void valUserEntityExists(String id) {
        if (!userService.exists(id)) {
            batchError("userPayrollGroupAuthorization.user.not.found");
        }
    }

    private void valPayrollGroupRequired(PayrollGroup payrollGroup) {
        if (payrollGroup == null) {
            batchError("userPayrollGroupAuthorization.payrollGroup.required");
        }
    }

    private void valPayrollIdVersionRequired(String id, Long version) {
        if (id == null || version == null) {
            batchError("userPayrollGroupAuthorization.payrollGroup.required");
        }
    }

    private void valPayrollGroupEntityExists(String id) {
        if (!payrollGroupService.exists(id)) {
            batchError("userPayrollGroupAuthorization.payrollGroup.not.found");
        }
    }

    private void valCompanyRequired(Company company) {
        if (company == null) {
            batchError("userPayrollGroupAuthorization.company.required");
        }
    }

    private void valCompanyEntityExists(String id) {
        if (!companyService.exists(id)) {
            batchError("userCompany.company.not.found");
        }
    }

    private void valCompanyEntityActive(String id) {
        Company entity = companyService.find(id).get();
        if (entity.getActive() == false) {
            batchError("userCompany.company.not.active");
        }
    }

    private void valCompanyIdVersionRequired(String id, Long version) {
        if (id == null || version == null) {
            batchError("userCompany.company.required");
        }
    }

    private void valCompanyVersion(String id, Long version) {
        valCompanyEntityExists(id);
        Company dbEntity = companyService.get(id);
        VersionUtil.check(version, dbEntity.getVersion());
    }
}