package com.sonymusic.dx.dxadvsearchservice.service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import com.sonymusic.dx.dxadvsearchservice.dto.CompanyDTO;
import com.sonymusic.dx.dxadvsearchservice.enums.CompanyType;
import com.sonymusic.dx.persistence.gras.*;
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.data.domain.Sort;
import org.springframework.stereotype.Service;

import com.sonymusic.dx.dxadvsearchservice.repository.CompanyRepository;
import com.sonymusic.dx.dxadvsearchservice.repository.ParentRepertoireOwnerRepository;
import com.sonymusic.dx.dxadvsearchservice.repository.ProfitCenterRepository;
import com.sonymusic.dx.dxadvsearchservice.repository.RepertoireOwnerRepository;

import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;

@Service
public class CompanyService {

	@PersistenceContext(name = "dx-gras-persistence")
	private EntityManager em;

	@Autowired
	CompanyRepository companyRepository;

	@Autowired
	RepertoireOwnerRepository repertoireOwnerRepository;

	@Autowired
	ProfitCenterRepository profitCenterRepository;

	@Autowired
	ParentRepertoireOwnerRepository parentRepertoireOwnerRepository;


	public Map<String,Object> getCompanyList(String name, int page, int size,int type) {

		CompanyType companyType = CompanyType.fromCode(type);
		Map<String,Object> result= new HashMap<>();
		if (page == 0){
			result.put("Status","failed");
			result.put("message","Invalid page number");
			return result;
		}
		switch (companyType){
			case REPERTOIRE_OWNER -> {
				Pageable pageable = PageRequest.of(page-1,size,Sort.by("company"));

				if (name!=null && !name.trim().isEmpty()) {
					Page<RepertoireOwner> company = repertoireOwnerRepository.findByCompany_CompanyNameIgnoreCaseContainingOrCompany_CompanyKeyIgnoreCaseContaining(name.trim(), name.trim(), pageable);
					List<CompanyDTO> companyDTOList = company.stream()
							.map(c-> new CompanyDTO(c.getCompany().getCompanyKey(),c.getCompany().getCompanyName()))
							.collect(Collectors.toList());
					return mapToCompanyDTO(company,page,companyDTOList);

				}else {

					Page<RepertoireOwner> company = repertoireOwnerRepository.findAll(pageable);
					List<CompanyDTO> companyDTOList = company.stream()
							.map(c-> new CompanyDTO(c.getCompany().getCompanyKey(),c.getCompany().getCompanyName()))
							.collect(Collectors.toList());
					return mapToCompanyDTO(company,page,companyDTOList);
				}

			}
			case PROFIT_CENTER -> {
				Pageable pageable = PageRequest.of(page-1,size,Sort.by("company"));
				if (name!=null && !name.trim().isEmpty()) {
					Page<ProfitCenter> profitCenter = profitCenterRepository.findByCompany_CompanyNameIgnoreCaseContainingOrCompany_CompanyKeyIgnoreCaseContaining(name.trim(), name.trim(), pageable);
					List<CompanyDTO> companyDTOList = profitCenter.stream()
							.map(c-> new CompanyDTO(c.getCompany().getCompanyKey(),c.getCompany().getCompanyName()))
							.collect(Collectors.toList());
					return mapToCompanyDTO(profitCenter,page,companyDTOList);
				} else {
					Page<ProfitCenter> profitCenter = profitCenterRepository.findAll(pageable);
					List<CompanyDTO> companyDTOList = profitCenter.stream()
							.map(c-> new CompanyDTO(c.getCompany().getCompanyKey(),c.getCompany().getCompanyName()))
							.collect(Collectors.toList());
					return mapToCompanyDTO(profitCenter,page,companyDTOList);
				}
			}
			case PARENT_REPERIOIRE_OWNER -> {
				Pageable pageable = PageRequest.of(page-1,size,Sort.by("company"));
				if (name!=null && !name.trim().isEmpty()) {
					Page<ParentRepertoireOwner> parentRepertoireOwner = parentRepertoireOwnerRepository.findByCompany_CompanyNameIgnoreCaseContainingOrCompany_CompanyKeyIgnoreCaseContaining(name.trim(), name.trim(), pageable);
					List<CompanyDTO> companyDTOList = parentRepertoireOwner.stream()
							.map(c-> new CompanyDTO(c.getCompany().getCompanyKey(),c.getCompany().getCompanyName()))
							.collect(Collectors.toList());
					return mapToCompanyDTO(parentRepertoireOwner,page,companyDTOList);
				}else {
					Page<ParentRepertoireOwner> parentRepertoireOwner = parentRepertoireOwnerRepository.findAll(pageable);
					List<CompanyDTO> companyDTOList = parentRepertoireOwner.stream()
							.map(c-> new CompanyDTO(c.getCompany().getCompanyKey(),c.getCompany().getCompanyName()))
							.collect(Collectors.toList());
					return mapToCompanyDTO(parentRepertoireOwner,page,companyDTOList);
				}
			}

		}

        return result;
    }

	public <T,D> Map<String,Object> mapToCompanyDTO(Page<T> companyList, int page,List<CompanyDTO> list){
		Map<String,Object> result= new HashMap<>();
		result.put("data",list);
		result.put("totalCount",companyList.getTotalElements());
		result.put("page", page);
		result.put("totalPage",companyList.getTotalPages());
		return result;
	}

	public Map<String,Object> getMaintenanceOwner(String name, int page, int size) {

		Pageable pageable = PageRequest.of(page-1,size,Sort.by("companyName"));
		if(name!=null && !name.trim().isEmpty()){
			Page<Company> company = companyRepository.findByIsActiveMaintOwnerTrueAndCompanyNameIgnoreCaseContainingOrIsActiveMaintOwnerTrueAndCompanyKeyIgnoreCaseContaining(name.trim(), name.trim(), pageable);
			List<CompanyDTO> companyDTOList = company.stream()
					.map(c-> new CompanyDTO(c.getCompanyKey(),c.getCompanyName()))
					.collect(Collectors.toList());
			return mapToCompanyDTO(company,page,companyDTOList);
		}

		Page<Company> company = companyRepository.findByIsActiveMaintOwner(true, pageable);
		List<CompanyDTO> companyDTOList = company.stream()
				.map(c-> new CompanyDTO(c.getCompanyKey(),c.getCompanyName()))
				.collect(Collectors.toList());
		return mapToCompanyDTO(company,page,companyDTOList);

	}

	public Map<String, Object> getInitiator(String name,int page, int size) {
		Pageable pageable = PageRequest.of(page-1,size,Sort.by("companyName"));

		if(name!=null && !name.trim().isEmpty()){
			Page<Company> company = companyRepository.findByisActiveInitTrueAndCompanyNameIgnoreCaseContaining(name.trim(), pageable);
			List<CompanyDTO> companyDTOList = company.stream()
					.map(c-> new CompanyDTO(c.getCompanyKey(),c.getCompanyName()))
					.collect(Collectors.toList());
			return mapToCompanyDTO(company,page,companyDTOList);
		}
		Page<Company> company = companyRepository.findByisActiveInit(true,pageable);
		List<CompanyDTO> companyDTOList = company.stream()
				.map(c-> new CompanyDTO(c.getCompanyKey(),c.getCompanyName()))
				.collect(Collectors.toList());
		return mapToCompanyDTO(company,page,companyDTOList);

	}
}