import { CompanyConnector } from '../connectors/CompanyConnector';
import { ShipsConnector } from '../connectors/ShipsConnector';
import { DreamlinesModels } from 'dreamlines-product-api-client';
import { ProductApiClient, ISearchQuery} from 'dreamlines-product-api-client';
import { IConfiguration } from '../config/Configuration';
import { FilterParams } from '../models/FilterParams';
import { CompanyDetailCmsData } from '../models/cms/CompanyDetailCmsData';
import { IShipPageUris } from '../interfaces/IShipDetailPageData';
import { BaseDataConnector } from '../connectors/BaseDataConnector';
import { CompanyOverviewCmsData } from '../models/cms/CompanyOverviewCmsData';
import { RelevanceUriData } from '../models/cms/CompanyOverviewCmsData';
import { ICompanyData } from '../interfaces/ICompanyOverviewPageData';
import { PageConnector } from '../connectors/PageConnector';
import { companyOverviewPageTable } from '../consts/sqlTableNames';
import { IBreadcrumb } from '../interfaces/IBreadcrumb';
import { UGCService } from '../services/UGCService';
import { IUGC } from '../interfaces/IUGC';
import { ICruiseOffers } from '../interfaces/ICruisePage';
import { generateOffers } from '../helpers/cruiseHelpers';

interface ICompanyDetailPageDataMobile {
    dataFromCms:CompanyDetailCmsData;
    companyData:DreamlinesModels.ICompany;
    cruises:DreamlinesModels.ISearchResult;
    ships:DreamlinesModels.IShip[];
    shipPageUris:IShipPageUris;
    parentBreadcrumb: IBreadcrumb;
    reviews: IUGC;
    offers: ICruiseOffers;
}

interface ICompanyOverviewPageDataMobile {
    dataFromCms: CompanyOverviewCmsData;
    companyData: ICompanyData;
    relevanceUriData: RelevanceUriData;
    topCompanyNids: number[];
}

export class CompanyRepository {
    private targetCurrency: string;
    private sourceCurrency: string;

    constructor(
        private environment:IConfiguration,
        private companyConnector:CompanyConnector,
        private shipConnector:ShipsConnector,
        private productApiClient: ProductApiClient,
        private baseDataConnector: BaseDataConnector,
        private pageConnector: PageConnector,
        private ugcService: UGCService,
    ) {
        this.targetCurrency = this.environment.brandSpecification.dualCurrency || this.environment.brandSpecification.defaultCurrency;
        this.sourceCurrency = this.environment.brandSpecification.defaultCurrency;
    }

    public getCompanyDetailPageDataMobile = async (uri:string):Promise<ICompanyDetailPageDataMobile> => {
        try {
            const [
                dataFromCms,
                parentBreadcrumb
            ] = await Promise.all([
                this.companyConnector.fetchCompanyDetailPage(uri),
                this.pageConnector.getPageBreadcrumb({
                    tableName: companyOverviewPageTable
                })
            ]);

            const filterParams = new FilterParams();
            filterParams.company = [dataFromCms.companyId];
            const { countryCode } = this.environment.brandSpecification;

            const [
                companyData,
                cruises,
                ships,
                reviews,
                cheapestCruise
            ] = await Promise.all([
                this.getCompanyData(dataFromCms.companyId),
                this.getCruiseRecommendations(dataFromCms.companyId),
                this.getShipList(dataFromCms.companyId),
                this.ugcService.getShipCompositeRating({
                    filterParams: {
                        productApiOperatorId: dataFromCms.companyId,
                        language: countryCode !== 'br' ? countryCode : 'pt'
                    }
                }),
                this.productApiClient.doSearchRequest({
                    countryCode,
                    limit: 1,
                    offset: 0,
                    sortString: 'price',
                    filterParams
                })
            ]);

            const shipPageUris = await this.getShipPageUris(ships);

            return {
                dataFromCms,
                companyData,
                cruises,
                ships,
                shipPageUris,
                parentBreadcrumb,
                reviews,
                offers: generateOffers(cheapestCruise)
            };
        } catch (error) {
            throw error;
        }
    };

    public getCompanyOverviewPageDataMobile = async (uri: string): Promise<ICompanyOverviewPageDataMobile> => {
        try {
            const [
                dataFromCms,
                companyData,
                relevanceUriData,
                topCompanyNids
            ] = await Promise.all([
                this.companyConnector.fetchCompanyOverviewPage(uri),
                this.getAllCompanies(),
                this.companyConnector.fetchCompanyUriRelevance(),
                this.getTopCompanyNids()
            ]);

            return {
                dataFromCms,
                companyData,
                relevanceUriData,
                topCompanyNids
            };
        } catch (error) {
            throw error;
        }
    };

    public getShipList = async (companyId:number):Promise<DreamlinesModels.IShip[]> => {
        const filterParams = new FilterParams();
        filterParams.company = [companyId];

        let query:ISearchQuery = {
            countryCode: this.environment.brandSpecification.countryCode,
            limit: 5,
            offset: 0,
            sortString: '',
            filterParams: filterParams
        };

        try {
            const ships = await this.productApiClient.doShipSearchRequest(query);
            const shipData: DreamlinesModels.IShipSearchResult = ships;
            //This is a hack because Product API returns ships wrapped in an object instead an array of ships
            const shipDataKeys = Object.keys(shipData.ships);
            const shipList = [];
            shipDataKeys.forEach(val => shipList.push(shipData.ships[val]));
            return shipList;
        } catch (error) {
            throw error;
        }
    };

    public getCompanyData = (companyId:number):Promise<DreamlinesModels.ICompany> => {
        return this.productApiClient.doCompanyContentRequest(this.environment.brandSpecification.countryCode, companyId);
    };

    public getCruiseRecommendations = (companyId:number):Promise<DreamlinesModels.ISearchResult> => {
        const filterParams = new FilterParams();
        filterParams.company = [companyId];

        let query:ISearchQuery = {
            countryCode: this.environment.brandSpecification.countryCode,
            limit: 5,
            offset: 0,
            sortString: 'relevance',
            filterParams: filterParams
        };

        return this.productApiClient.doSearchRequest(query);
    };

    public getShipPageUris = (ships:DreamlinesModels.IShip[]):Promise<IShipPageUris> => {
        const shipNids = ships.map((ship) => ship.nid);
        return this.shipConnector.fetchShipPageUris(shipNids);
    }

    public getAllCompanies = ():Promise<ICompanyData> => {
        return this.productApiClient.doCompanyContentRequest(this.environment.brandSpecification.countryCode);
    };

    public getTopCompanyNids = async ():Promise<number[]> => {
        try {
            const rawTopCompanies = await this.baseDataConnector.getDBField('TopCompanies');
            return JSON.parse(rawTopCompanies);
        } catch (error) {
            throw error;
        }
    }
}