package net.gepafin.tendermanagement.dao;

import net.gepafin.tendermanagement.config.Translator;
import net.gepafin.tendermanagement.constants.GepafinConstant;
import net.gepafin.tendermanagement.entities.RoleEntity;
import net.gepafin.tendermanagement.model.request.RoleReq;
import net.gepafin.tendermanagement.model.response.RegionResponseBean;
import net.gepafin.tendermanagement.model.response.RoleResponseBean;
import net.gepafin.tendermanagement.repositories.RoleRepository;
import net.gepafin.tendermanagement.service.RegionService;
import net.gepafin.tendermanagement.util.Utils;
import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
import net.gepafin.tendermanagement.web.rest.api.errors.Status;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.stream.Collectors;

import static net.gepafin.tendermanagement.util.ObjectUtils.setIfUpdated;

@Component
public class RoleDao {
    private final Logger log = LoggerFactory.getLogger(RoleDao.class);

    @Autowired
    private RoleRepository roleRepository;

    @Autowired
    private RegionService regionService;

    @Autowired
    private RegionDao regionDao;

    public RoleResponseBean createRole(RoleReq roleReq) {
        log.info("Creating new role with details: {}", roleReq);
        RoleEntity roleEntity = convertRoleRequestToRoleEntity(roleReq);
        roleEntity = roleRepository.save(roleEntity);
        log.info("Role created with ID: {}", roleEntity.getId());
        return convertRoleEntityToRoleResponse(roleEntity);
    }

    private RoleEntity convertRoleRequestToRoleEntity(RoleReq roleReq) {
        RoleEntity roleEntity = new RoleEntity();
        roleEntity.setRoleName(roleReq.getRoleName());
        roleEntity.setRoleType(roleReq.getRoleType());
        roleEntity.setPermissions(roleReq.getPermissions());
        roleEntity.setDescription(roleReq.getDescription());
        roleEntity.setRegion(regionService.getRegionById(roleReq.getRegionId()));
        return roleEntity;
    }

    public RoleResponseBean convertRoleEntityToRoleResponse(RoleEntity roleEntity) {
        RoleResponseBean roleResponseBean = new RoleResponseBean();
        roleResponseBean.setId(roleEntity.getId());
        roleResponseBean.setCreatedDate(roleEntity.getCreatedDate());
        roleResponseBean.setUpdatedDate(roleEntity.getUpdatedDate());
        roleResponseBean.setRoleName(roleEntity.getRoleName());
        roleResponseBean.setRoleType(roleEntity.getRoleType());
        roleResponseBean.setDescription(roleEntity.getDescription());
        roleResponseBean.setPermissions(roleEntity.getPermissions());
        RegionResponseBean regionResponseBean = regionDao.convertRegionEntityToRegionResponse(roleEntity.getRegion());
        roleResponseBean.setRegion(regionResponseBean);
        return roleResponseBean;
    }

    public RoleResponseBean updateRole(Long id, RoleReq roleReq) {
        log.info("Updating role with ID: {}", id);
        RoleEntity existingRole = getRoleById(id);

        // Log changes before update
        log.info("Current role details: {}", existingRole);
        log.info("New role details: {}", roleReq);

        setIfUpdated(existingRole::getRoleName, existingRole::setRoleName, roleReq.getRoleName());
        setIfUpdated(existingRole::getRoleType, existingRole::setRoleType, roleReq.getRoleType());
        setIfUpdated(existingRole::getDescription, existingRole::setDescription, roleReq.getDescription());
        setIfUpdated(existingRole::getPermissions, existingRole::setPermissions, roleReq.getPermissions());

        existingRole = roleRepository.save(existingRole);

        log.info("Role updated with ID: {}", existingRole.getId());
        return Utils.convertObject(existingRole, RoleResponseBean.class);
    }

    public RoleEntity getRoleById(Long id) {
        log.info("Fetching role with ID: {}", id);
        RoleEntity roleEntity = roleRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.ROLE_NOT_FOUND)));
        log.info("Role found: {}", roleEntity);
        return roleEntity;
    }

    public void deleteById(Long id) {
        log.info("Deleting role with ID: {}", id);
        roleRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.ROLE_NOT_FOUND)));
        roleRepository.deleteById(id);
        log.info("Role deleted with ID: {}", id);
    }

    public List<RoleResponseBean> getAllRoles() {
        log.info("Fetching all roles");
        List<RoleResponseBean> roles = roleRepository.findAll()
                .stream()
                .map(roleEntity -> Utils.convertObject(roleEntity, RoleResponseBean.class))
                .collect(Collectors.toList());
        log.info("Total roles found: {}", roles.size());
        return roles;
    }
}