package com.napa.pulse.service.impl;

import com.napa.pulse.dao.interfaces.MajorAccountSiteDAO;
import com.napa.pulse.dto.MajorAccountSiteDTO;
import com.napa.pulse.dto.SiteInvCollTemplate;
import com.napa.pulse.entity.pulseui.*;
import com.napa.pulse.entity.security.User;
import com.napa.pulse.repository.*;
import com.napa.pulse.service.interfaces.MajorAccountService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
public class MajorAccountServiceImpl implements MajorAccountService {

    private static final Logger LOGGER = LoggerFactory.getLogger(MajorAccountServiceImpl.class);

    @Autowired
    private MajorAccountRepository majorAccountRepository;

    @Autowired
    private PricingProfileRepository pricingProfileRepository;

    @Autowired
    private ExportColumnNameRepository exportColumnNameRepository;

    @Autowired
    private InvestmentCollectionRepository investmentCollectionRepository;

    @Autowired
    private InvCollTemplateRepository invCollTemplateRepository;

    @Autowired
    private SiteRepository siteRepository;

    @Autowired
    private MajorAccountSiteDAO majorAccountSiteDao;

    @Override
    public Iterable<MajorAccount> getAllMajorAccounts(boolean includeInactive) {
        Iterable<ExportColumn> allColumns = getAllExportColumnNames();
        Iterable<MajorAccount> majorAccounts;

        if (includeInactive) {
            majorAccounts = majorAccountRepository.findAll();
        } else {
            majorAccounts = majorAccountRepository.findByActive(true);
        }

        majorAccounts.forEach((account) -> {
            List<MajorAccountExportColumn> newColumns = new ArrayList<>();
            Map<Long, MajorAccountExportColumn> map = account.getExportColumns()
                    .stream()
                    .collect(Collectors.toMap((item) -> item.getId().getExportColumn().getId(), (item) -> item));

            for (ExportColumn column : allColumns) {
                MajorAccountExportColumn selectedColumn = map.get(column.getId());
                if (selectedColumn == null) {
                    MajorAccountExportColumn availableColumn = new MajorAccountExportColumn();
                    MajorAccountExportColumnId id = new MajorAccountExportColumnId();
                    id.setExportColumn(column);
                    availableColumn.setId(id);
                    availableColumn.setOrder(column.getColumnOrder());
                    availableColumn.setSelected(false);
                    newColumns.add(availableColumn);
                } else {
                    newColumns.add(selectedColumn);
                }
            }

            newColumns.sort(new MajorAccountExportColumnComparator());
            account.setExportColumns(newColumns);
        });

        return majorAccounts;
    }

    @Override
    @Transactional
    @Modifying
    public MajorAccount saveMajorAccount(MajorAccount majorAccount) {
        // enforce/correct column order
        List<MajorAccountExportColumn> reqList = new ArrayList<>();
        List<MajorAccountExportColumn> optList = new ArrayList<>();

        for (MajorAccountExportColumn column : majorAccount.getExportColumns()) {
            if (column.getId().getExportColumn().isRequired()) {
                reqList.add(column);
            } else {
                optList.add(column);
            }
        }

        int order = 0;
        // sort the required columns based on their underlying order in export_column
        reqList.sort((c1, c2) -> c1.getId().getExportColumn().getColumnOrder() < c2.getId().getExportColumn().getColumnOrder() ? -1 : 1);
        // sort the option columns based on their order in ma_export_column
        optList.sort((c1, c2) -> c1.getOrder() < c2.getOrder() ? -1 : 1);
        // now assign their column order, first the required columns, then the optional in their requested order

        for (MajorAccountExportColumn column : reqList) {
            column.setOrder(order++);
            column.setSelected(true);
        }

        for (MajorAccountExportColumn column : optList) {
            column.setOrder(order++);
        }

        return majorAccountRepository.save(majorAccount);
    }

    @Override
    public void deleteMajorAccount(Long majorAccountId) {
        majorAccountRepository.deleteById(majorAccountId);
    }

    @Override
    public Iterable<ExportColumn> getAllExportColumnNames() {
        return exportColumnNameRepository.findByExportTypeOrderByColumnOrder("major_account");
    }

    @Override
    public Iterable<InvestmentCollection> getAllInvestmentCollections() {
        return investmentCollectionRepository.findAll();
    }

    @Override
    public Iterable<InvestmentCollection> getInvestmentCollectionsForSites(Integer[] siteIds) {
        return investmentCollectionRepository.loadBySiteId(Arrays.asList(siteIds));
    }

    @Override
    public InvestmentCollection saveInvestmentCollection(InvestmentCollection investmentCollection) {
        return investmentCollectionRepository.save(investmentCollection);
    }

    @Override
    public Iterable<PricingProfile> getAllPricingProfiles() {
        return pricingProfileRepository.findAll();
    }

    @Override
    public Iterable<Site> getAllServicingStoresForDc(int dcId) {
        return siteRepository.getAllServicingStoresForDc(dcId);
    }

    @Override
    public Iterable<Site> getAllServicingDcs() {
        return siteRepository.findAllServicingDcs();
    }

    @Override
    public void updateSite(User user, MajorAccountSiteDTO site) {
        majorAccountSiteDao.updateSite(user, site);
    }

    @Override
    public void createSite(User user, MajorAccountSiteDTO site) throws Exception {
        majorAccountSiteDao.createSite(user, site);
    }

    @Override
    public MajorAccountSiteDTO getSiteDetails(Long siteId) {
        return majorAccountSiteDao.getSiteDetails(siteId);
    }

    @Override
    public Iterable<InvestmentCollectionTemplate> getAllInvestmentCollectionTemplates(boolean includeInactive) {
        if (includeInactive) {
            return invCollTemplateRepository.findAllByOrderByName();
        }
        return invCollTemplateRepository.findByActiveOrderByName(true);
    }

    @Override
    public InvestmentCollectionTemplate saveInvestmentCollectionTemplate(InvestmentCollectionTemplate investmentCollectionTemplate) {
        if (investmentCollectionTemplate.getId() > 0) {
            investmentCollectionRepository.saveAll(investmentCollectionTemplate.getInvestmentCollections());
        }
        return invCollTemplateRepository.save(investmentCollectionTemplate);
    }

    @Override
    public void updateInvestmentCollectionForSites(Long investmentCollectionTemplateId, Long[] siteIds) {
        majorAccountSiteDao.updateSitesMajorAccount(siteIds, investmentCollectionTemplateId);
    }

    @Override
    public Iterable<SiteInvCollTemplate> getInvCollTemplatesForSites(Integer[] siteIds) throws SQLException {
        return majorAccountSiteDao.getInvCollTemplatesForSites(siteIds);
    }

}