package net.gepafin.tendermanagement.dao;

import net.gepafin.tendermanagement.constants.GepafinConstant;
import net.gepafin.tendermanagement.entities.CompanyEntity;
import net.gepafin.tendermanagement.entities.UserActionEntity;
import net.gepafin.tendermanagement.entities.UserEntity;
import net.gepafin.tendermanagement.entities.UserWithCompanyEntity;
import net.gepafin.tendermanagement.entities.*;
import net.gepafin.tendermanagement.enums.CallStatusEnum;
import net.gepafin.tendermanagement.enums.RoleStatusEnum;
import net.gepafin.tendermanagement.enums.UserStatusEnum;
import net.gepafin.tendermanagement.model.response.ApplicationWidgetResponseBean;
import net.gepafin.tendermanagement.model.response.BeneficiaryWidgetResponseBean;
import net.gepafin.tendermanagement.model.response.Widget1;
import net.gepafin.tendermanagement.model.response.SuperAdminWidgetResponseBean;
import net.gepafin.tendermanagement.repositories.*;
import net.gepafin.tendermanagement.service.CompanyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.List;
import java.util.List;
import java.util.stream.Collectors;

@Component
public class DashboardDao {

	@Autowired
	private CallRepository callRepository;

	@Autowired
	private UserRepository userRepository;

	@Autowired
	private ApplicationRepository applicationRepository;

	@Autowired
	private CompanyRepository companyRepository;

	@Autowired
	private CompanyService companyService;
	@Autowired
	private BeneficiaryPreferredCallRepository beneficiaryPreferredCallRepository;


	@Autowired
	private ApplicationEvaluationRepository applicationEvaluationRepository;

	@Autowired
	private UserActionsRepository userActionsRepository;

	public SuperAdminWidgetResponseBean getDashboardWidget(UserEntity requestedUserEntity) {
		SuperAdminWidgetResponseBean widgetResponseBean = new SuperAdminWidgetResponseBean();
		widgetResponseBean.setWidget1(createWidget1(requestedUserEntity));
		Map<String, Object> widgetBars =getStatistics(requestedUserEntity);
        widgetResponseBean.setWidgetBars(widgetBars);
		return widgetResponseBean;
	}

	private Widget1 createWidget1(UserEntity requestedUserEntity) {
		Widget1 widget1 = initializeWidget1();

		setActiveCalls(widget1, requestedUserEntity);
		setRegisteredUsers(widget1, requestedUserEntity);
		setTotalActiveFinancing(widget1, requestedUserEntity);
		setSubmittedApplications(widget1, requestedUserEntity);
		setDraftApplications(widget1, requestedUserEntity);
		setNumberOfCompanies(widget1, requestedUserEntity);
		setAmountRequested(widget1,requestedUserEntity);
		setAmountAccepted(widget1,requestedUserEntity);
		return widget1;
	}

	private Widget1 initializeWidget1() {
		return Widget1.builder().numberOfActiveCalls(0L).numberOfCompany(0L).numberOfDraftApplications(0L)
				.numberOfResgisteredUsers(0L).numberOfSubmittedApplications(0L).totalActiveFinancing(BigDecimal.ZERO)
				.build();
	}

	private void setActiveCalls(Widget1 widget1, UserEntity requestedUserEntity) {
		Long activeCalls = callRepository.countByStatusAndHubId(CallStatusEnum.PUBLISH.getValue(), requestedUserEntity.getHub().getId());
		if (activeCalls != null) {
			widget1.setNumberOfActiveCalls(activeCalls);
		}
	}

	private void setAmountRequested(Widget1 widget1, UserEntity requestedUserEntity) {
		BigDecimal amountRequested = applicationRepository.findTotalAmountRequestedOfApplication(requestedUserEntity.getHub().getId());
		if (amountRequested != null) {
			widget1.setTotalAmountRequested(amountRequested);
		}
	}

	private void setAmountAccepted(Widget1 widget1, UserEntity requestedUserEntity) {
		BigDecimal amountAccepted = applicationRepository.findTotalAmountAcceptedOfApplication(requestedUserEntity.getHub().getId());
		if (amountAccepted != null) {
			widget1.setTotalAmountAccepted(amountAccepted);
		}
	}

	private void setRegisteredUsers(Widget1 widget1, UserEntity requestedUserEntity) {
		Long activeUsers = userRepository.countByStatusAndRoleEntityRoleTypeAndHubId(UserStatusEnum.ACTIVE.getValue(),
				RoleStatusEnum.ROLE_BENEFICIARY.getValue(), requestedUserEntity.getHub().getId());
		if (activeUsers != null) {
			widget1.setNumberOfResgisteredUsers(activeUsers);
		}
	}

	private void setTotalActiveFinancing(Widget1 widget1, UserEntity requestedUser) {
		BigDecimal totalActiveFinancing = callRepository.findTotalAmountOfPublishedCallsAndHubId(requestedUser.getHub().getId());
		widget1.setTotalActiveFinancing(totalActiveFinancing);
	}

	private void setSubmittedApplications(Widget1 widget1, UserEntity requestedUserEntity) {
		Long submittedApplications = applicationRepository.countSubmittedApplicationsByHubId(requestedUserEntity.getHub().getId());
		if (submittedApplications != null) {
			widget1.setNumberOfSubmittedApplications(submittedApplications);
		}
	}

	private void setDraftApplications(Widget1 widget1, UserEntity requestedUserEntity) {
		Long draftApplications = applicationRepository.countDraftApplicationsByHubId(requestedUserEntity.getHub().getId());
		if (draftApplications != null) {
			widget1.setNumberOfDraftApplications(draftApplications);
		}
	}

	private void setNumberOfCompanies(Widget1 widget1, UserEntity requestedUserEntity) {
		Long numberOfCompanies = companyRepository.countTotalCompaniesByHubId(requestedUserEntity.getHub().getId());
		if (numberOfCompanies != null) {
			widget1.setNumberOfCompany(numberOfCompanies);
		}
	}

	public BeneficiaryWidgetResponseBean getDashboardWidgetForBeneficiary(UserEntity userEntity,
																		  CompanyEntity company) {
		BeneficiaryWidgetResponseBean beneficiaryWidgetResponseBean = BeneficiaryWidgetResponseBean.builder()
				.numberOfApplications(0L).numberOfCalls(0L).numberOfIntegratedDocuments(0L).build();
		UserWithCompanyEntity userWithCompanyEntity = companyService.getUserWithCompany(userEntity.getId(), company.getId());

		List<BeneficiaryPreferredCallEntity> preferredCalls = beneficiaryPreferredCallRepository
				.findByUserIdAndUserWithCompanyIdAndIsDeletedFalse(userEntity.getId(), userWithCompanyEntity.getId());

		if (preferredCalls != null && !preferredCalls.isEmpty()) {
			List<Long> callIds = preferredCalls.stream()
					.map(BeneficiaryPreferredCallEntity::getCallId)
					.collect(Collectors.toList());
			List<CallEntity> callEntities = callRepository.findByIdIn(callIds);
			long activeCallsCount = callEntities.stream()
					.filter(call -> CallStatusEnum.PUBLISH.getValue().equals(call.getStatus())
							&& userEntity.getHub().getId().equals(call.getHub().getId()))
					.count();

			beneficiaryWidgetResponseBean.setNumberOfCalls(activeCallsCount);
		}
		Long activeApplication = applicationRepository.countSubmittedApplicationsByUserId(userEntity.getId(),
				userWithCompanyEntity.getId());
		if (activeApplication != null) {
			beneficiaryWidgetResponseBean.setNumberOfApplications(activeApplication);
		}
		return beneficiaryWidgetResponseBean;
	}

	public Map<String, Object> getStatistics(UserEntity requestedUser) {
		Map<String, Object> stats = new HashMap<>();

		// Get applications per call
		List<Object[]> applicationsPerCall = applicationRepository.findApplicationsPerCallWithName(requestedUser.getHub().getId());
		stats.put(GepafinConstant.APPLICATION_PER_CALL, applicationsPerCall.stream().map(result -> {
			Map<String, Object> callData = new HashMap<>();
			callData.put(GepafinConstant.CALL_NAME, result[0]);  // Call name
			callData.put(GepafinConstant.NUMBER_OF_APPLICATIONS, result[1]);  // Application count
			return callData;
		}).toList());

		// Get applications grouped by status
		List<Object[]> applicationsByStatus = applicationRepository.findApplicationsByStatus(requestedUser.getHub().getId());
		stats.put(GepafinConstant.APPLICATION_PER_STATUS, applicationsByStatus.stream().map(result -> {
			Map<String, Object> statusData = new HashMap<>();
			statusData.put(GepafinConstant.STATUS, result[0]);  // Application status
			statusData.put(GepafinConstant.NUMBER_OF_APPLICATIONS, result[1]);  // Count of applications
			return statusData;
		}).toList());

		return stats;
	}
//	public Page<UserActionEntity> getUserAction(UserEntity requestedUserEntity){
//		Pageable pageable = PageRequest.of(0, 20); // Get the first 20 records
//		List<String> roles=List.of(RoleStatusEnum.ROLE_PRE_INSTRUCTOR.getValue(),RoleStatusEnum.ROLE_GEPAFIN_OPERATOR.getValue(),RoleStatusEnum.ROLE_INSTRUCTOR_MANAGER.getValue());
//		Page<UserActionEntity> userActionEntities=userActionsRepository.findActionsByRoleNamesAndHubId(roles,requestedUserEntity.getHub().getId(),pageable);
//		return userActionEntities;
//	}
	public ApplicationWidgetResponseBean getApplicationDetails(UserEntity userEntity) {
		ApplicationWidgetResponseBean applicationWidgetResponseBean = initializeResponseBean();

		Long hubId = userEntity.getHub().getId();

		setApplicationCounts(applicationWidgetResponseBean, hubId);
		calculateEvaluationAverageTime(applicationWidgetResponseBean, hubId);

		return applicationWidgetResponseBean;
	}

	private ApplicationWidgetResponseBean initializeResponseBean() {
		return ApplicationWidgetResponseBean.builder()
				.numberOfApplication(0L)
				.numberOfAssignedApplication(0L)
				.numberOfAcceptedApplication(0L)
				.numberOfApplicationInAmendmentState(0L)
				.numberOfDueApplication(0L)
				.evaluationAverageTime(BigDecimal.ZERO)
				.build();
	}

	private void setApplicationCounts(ApplicationWidgetResponseBean responseBean, Long hubId) {
		Long activeApplications = applicationRepository.countApplicationsByHubId(hubId);
		if (activeApplications != null) {
			responseBean.setNumberOfApplication(activeApplications);
		}

		Long assignedApplications = applicationRepository.countAssignedApplicationsByHubId(hubId);
		if (assignedApplications != null) {
			responseBean.setNumberOfAssignedApplication(assignedApplications);
		}

		Long approvedApplications = applicationRepository.countApprovedApplicationsByHubId(hubId);
		if (approvedApplications != null) {
			responseBean.setNumberOfAcceptedApplication(approvedApplications);
		}

		Long soccorsoApplications = applicationRepository.countSoccorsoApplicationsByHubId(hubId);
		if (soccorsoApplications != null) {
			responseBean.setNumberOfApplicationInAmendmentState(soccorsoApplications);
		}
	}

	private void calculateEvaluationAverageTime(ApplicationWidgetResponseBean responseBean, Long hubId) {
		List<Long> applicationIds = applicationRepository.findApplicationIdsByHubId(hubId);

		if (Boolean.FALSE.equals(applicationIds.isEmpty())) {
			BigDecimal averageTime = applicationEvaluationRepository.findAverageEvaluationTimeByApplicationIds(applicationIds);
			responseBean.setEvaluationAverageTime(averageTime != null ? averageTime : BigDecimal.ZERO);
		}
		LocalDate twoDaysLater = LocalDate.now().plusDays(2);

		Long dueApplications = applicationEvaluationRepository.countDueApplicationsBetween(
				applicationIds,
				LocalDate.now(),
				twoDaysLater
		);

		if (dueApplications != null) {
			responseBean.setNumberOfDueApplication(dueApplications);
		}
	}


}