import React, { createContext, useContext, useMemo } from 'react';
import PropTypes from 'prop-types';
import {
	soknadPropType,
	tiltakRekkefolgeKonfigPropType,
} from '../domene/proptypes';
import { comparatorFraRekkefolgeIListe, useRefLazy } from '../utils/utils';
import { Gyldighet } from '..';
import { Soknad, Vegarbeid } from '../domene/Soknad';

type Sorterer = (verdiA: string, verbiB: string) => number;
interface IOppsummeringContext {
	soknad: Soknad;
	forrigeSoknad?: Soknad;
	vegarbeid: Vegarbeid;
	id: string;
	plantype: 'SPESIELL' | 'GENERELL';
	gyldighet: Gyldighet;
	kunLesbar: boolean;
	lastNedVedleggUrl: (filId: string) => string;
	lastNedVedlegg: (filId: string, lastNedAutomatisk: boolean) => void;
	tiltakGenerellPlanSorterer: Sorterer;
	tiltakSpesiellPlanSorterer: Sorterer;
	forsendelsesversjon: number;
}

export interface TiltakRekkefolgeKonfig {
	generellPlan: string[];
	spesiellPlan: string[];
}

const OppsummeringContext = createContext<IOppsummeringContext>(
	{} as unknown as any
);

function OppsummeringWrapper(props) {
	const {
		soknad,
		forrigeSoknad,
		gyldighet,
		kunLesbar,
		lastNedVedleggUrl,
		lastNedVedlegg,
		rekkefolgeTiltakKonfig,
		children,
	} = props;
	const lokalGyldighet = useRefLazy(() => new Gyldighet());
	const { tiltakGenerellPlanSorterer, tiltakSpesiellPlanSorterer } =
		utledRekkefolgeTiltakSorterer(rekkefolgeTiltakKonfig);

	const oppsummeringGyldighet = gyldighet || lokalGyldighet;

	const forsendelsesversjon = parseInt(soknad.forsendelsesversjon, 10);

	return (
		<OppsummeringContext.Provider
			value={{
				soknad,
				forrigeSoknad,
				vegarbeid: soknad.vegarbeid,
				id: soknad.id,
				plantype: soknad.vegarbeid?.plantype,
				gyldighet: oppsummeringGyldighet,
				kunLesbar,
				lastNedVedleggUrl,
				lastNedVedlegg,
				tiltakGenerellPlanSorterer,
				tiltakSpesiellPlanSorterer,
				forsendelsesversjon,
			}}
		>
			{children}
		</OppsummeringContext.Provider>
	);
}

function utledRekkefolgeTiltakSorterer(
	tiltakRekkefolgeKonfig: TiltakRekkefolgeKonfig
) {
	const { generellPlan, spesiellPlan } = tiltakRekkefolgeKonfig || {};

	const tiltakGenerellPlanSorterer = useMemo(
		() => comparatorFraRekkefolgeIListe(generellPlan),
		[generellPlan]
	);
	const tiltakSpesiellPlanSorterer = useMemo(
		() => comparatorFraRekkefolgeIListe(spesiellPlan),
		[spesiellPlan]
	);

	return { tiltakGenerellPlanSorterer, tiltakSpesiellPlanSorterer };
}

function useOppsummering() {
	const context = useContext(OppsummeringContext);
	if (!context) {
		throw new Error(
			'useOppsummering må brukes innenfor <OppsummeringWrapper />'
		);
	}

	return context;
}

OppsummeringWrapper.propType = {
	soknad: soknadPropType.isRequired,
	forrigeSoknad: soknadPropType,
	gyldighet: PropTypes.instanceOf(Gyldighet),
	kunLesbar: PropTypes.bool,
	lastNedVedleggUrl: PropTypes.func,
	lastNedVedlegg: PropTypes.func,
	id: PropTypes.number,
	tiltakRekkefolgeKonfig: tiltakRekkefolgeKonfigPropType,
};

export { OppsummeringWrapper, useOppsummering };
