import React, { type FC, useEffect, useState } from 'react';
import {
    Alert,
    FullscreenModal,
    useFullscreenModal,
} from '@theorchard/suite-components';
import { formatMessage } from '@theorchard/suite-frontend';
import { useHistory, useParams } from 'react-router-dom';
import {
    useUpdateSongWriterMetaData,
    useUpdateSongWriterAgreements,
} from 'src/data/mutations';
import { useSongwriterByIdQuery } from 'src/data/queries/songwriterById/songwriterById';
import { type UpdatePublishingSongWriterMetaDataInput } from 'src/data/schemaTypes';
import {
    type AssociatedComposition,
    formatAssociatedComps,
    removePublisherNameFromAgreementsInput,
} from 'src/pages/songWriterEditModal/utils';
import AssociatedCompositions from './components/associatedCompositions';
import SongWriterModalBasics from './components/modalBasics';
import SongWriterModalHeader from './components/modalHeader';
import type { UpdateSongWriterAgreementsInput } from 'src/data/schemaTypes';
import type { Songwriter } from 'src/types';

export const CLASSNAME = 'SongWriterEditModal';

const SongWriterEditModal: FC<object> = () => {
    const history = useHistory<{ fromPage?: number; notification?: string }>();
    const [songwriter, setSongwriter] = useState<Songwriter | undefined>(
        (
            history.location.state as unknown as {
                songWriter: Songwriter | undefined;
            }
        )?.songWriter
    );
    const [updateSongWriter, setUpdateSongWriter] =
        useState<UpdatePublishingSongWriterMetaDataInput>({
            id: songwriter?.id ?? '',
            label: { uuid: songwriter?.vendor.uuid ?? '' },
            name: songwriter?.legalName ?? '',
            ipi: songwriter?.ipi ?? '',
            pro: songwriter?.pro ? songwriter.pro : '',
            professionallyKnownAs: songwriter?.professionallyKnownAs.length
                ? songwriter.professionallyKnownAs
                : null,
        });

    const [inputOnChanges, setInputOnChanges] = useState<
        UpdateSongWriterAgreementsInput | undefined
    >();
    const [baseModalErrors, setBaseModalErrors] = useState(false);
    const [hasSubmitted, setHasSubmitted] = useState(false);
    const [songWriterValidationErrorKeys, setSongWriterValidationErrorKeys] =
        useState<string[]>();

    const [initialControlledAgreements, setInitialControlledAgreements] =
        useState(
            songwriter?.agreements.filter(a => a.controlled).flatMap(a => a) ??
                []
        );
    const [initialNonControlledAgreements, setInitialNonControlledAgreements] =
        useState(
            songwriter?.agreements.filter(a => !a.controlled).flatMap(a => a) ??
                []
        );

    const [controlledComps, setControlledComps] = useState<
        AssociatedComposition[]
    >(formatAssociatedComps(initialControlledAgreements));

    const [nonControlledComps, setNonControlledComps] = useState<
        AssociatedComposition[]
    >(formatAssociatedComps(initialNonControlledAgreements));

    const { id } = useParams<{ id: string }>();

    const { data } = useSongwriterByIdQuery({ id });
    useEffect(() => {
        if (!songwriter && data) {
            setSongwriter(data);
            setUpdateSongWriter({
                id: data.id,
                label: { uuid: data.vendor.uuid },
                name: data.legalName,
                ipi: data.ipi ?? '',
                pro: data.pro ? data.pro : '',
                professionallyKnownAs: data.professionallyKnownAs ?? null,
            });
            setInitialControlledAgreements(
                data.agreements.filter(a => a.controlled).flatMap(a => a)
            );
            setInitialNonControlledAgreements(
                data.agreements.filter(a => !a.controlled).flatMap(a => a)
            );
        }
    }, [songwriter, data]);

    const { close } = useFullscreenModal();
    const closeModalCallback = (notification?: string) => {
        close(() =>
            history.push({
                pathname: `/song-writers/${history.location.state?.fromPage ?? 1}`,
                state: { notification },
            })
        );
    };

    const onSubmitCB = (
        result: object | null,
        errors: string[] | undefined
    ) => {
        if (result)
            closeModalCallback(
                formatMessage('songWriters.songwriterChangesSaved')
            );
        else if (errors) setSongWriterValidationErrorKeys(errors);
    };

    const updateSongWriterMetaData = useUpdateSongWriterMetaData(onSubmitCB);

    const updateSongWriterAgreements =
        useUpdateSongWriterAgreements(onSubmitCB);

    const controlledWriterMissingProIpi =
        controlledComps.length &&
        (updateSongWriter.pro === '' || updateSongWriter.ipi === '');

    const onSave = () => {
        setHasSubmitted(true);
        if (baseModalErrors) return;
        void updateSongWriterMetaData({ variables: updateSongWriter });

        if (songwriter && inputOnChanges) {
            void updateSongWriterAgreements({
                variables: {
                    input: {
                        ...inputOnChanges,
                        agreements: removePublisherNameFromAgreementsInput(
                            inputOnChanges.agreements
                        ),
                    },
                },
            });
        }
    };

    return (
        <FullscreenModal className={CLASSNAME}>
            {songwriter && (
                <>
                    <SongWriterModalHeader
                        songwriterData={songwriter}
                        saveDisabled={!!controlledWriterMissingProIpi}
                        saveModalCallback={onSave}
                        closeModalCallback={closeModalCallback}
                        controlledAgreements={initialControlledAgreements}
                        nonControlledAgreements={initialNonControlledAgreements}
                    />
                    <FullscreenModal.Body>
                        {!!controlledWriterMissingProIpi && (
                            <Alert
                                variant="error"
                                text={formatMessage(
                                    'songWriterManager.controlledCompsNoProIpi'
                                )}
                            />
                        )}
                        <SongWriterModalBasics
                            updateSongWriter={updateSongWriter}
                            setUpdateSongWriter={setUpdateSongWriter}
                            setBaseModalErrors={setBaseModalErrors}
                            hasSubmitted={hasSubmitted}
                            songWriterValidationErrorKeys={
                                songWriterValidationErrorKeys
                            }
                            setSongWriterValidationErrorKeys={
                                setSongWriterValidationErrorKeys
                            }
                            controlledComps={controlledComps}
                        />
                        <AssociatedCompositions
                            initialControlledAgreements={
                                initialControlledAgreements
                            }
                            initialNonControlledAgreements={
                                initialNonControlledAgreements
                            }
                            labelUuid={songwriter.vendor.uuid}
                            updatedWriter={updateSongWriter}
                            setUpdateSongWriterAgreementsInput={
                                setInputOnChanges
                            }
                            updateSongWriterAgreementsInput={inputOnChanges}
                            controlledComps={controlledComps}
                            setControlledComps={setControlledComps}
                            nonControlledComps={nonControlledComps}
                            setNonControlledComps={setNonControlledComps}
                        />
                    </FullscreenModal.Body>
                </>
            )}
        </FullscreenModal>
    );
};

export default SongWriterEditModal;