import React from 'react';
import type { FC } from 'react';
import { Modal } from '@theorchard/suite-components';
import { keyBy } from 'lodash';
import { flushSync } from 'react-dom';
import { useCurrentValidationContext } from 'src/components/currentValidationProvider/currentValidationProvider';
import { EMPTY_CHAR } from 'src/constants';
import { useTracksQuery } from 'src/data/queries/tracks';
import { OATrackEditPageURL } from 'src/utils/oa';
import MatchesTable from './matchesTable';
import type { Track } from 'src/data/queries/tracks/types';
import type {
    CrossAccountOsrConflictValidationMatch,
    PotentialAudioInfringementModalTableData,
    PotentialAudioInfringementValidationMatch,
    TrackFieldValidationExtra,
} from 'src/types';

export const CLASS_NAME = 'PotentialAudioInfringementModal';
export const INTL_PREFIX = 'contentReview.potentialAudioInfringementModal';

interface PotentialAudioInfringementModalProps {
    isOpen: boolean;
    onRequestClose: () => void;
    potentialAudioInfringementMatches: PotentialAudioInfringementValidationMatch[];
    crossAccountOSRConflictMatches: CrossAccountOsrConflictValidationMatch[];
    trackMetadata: TrackFieldValidationExtra;
}

const PotentialAudioInfringementModal: FC<
    PotentialAudioInfringementModalProps
> = ({
    isOpen,
    onRequestClose,
    potentialAudioInfringementMatches,
    crossAccountOSRConflictMatches,
    trackMetadata,
}) => {
    const {
        state: { currentValidation },
        dispatch: validationDispatch,
    } = useCurrentValidationContext();
    const { data: tracksData, loading: trackDataLoading } = useTracksQuery({
        tuids: crossAccountOSRConflictMatches.map(item => item.tuid.toString()),
        filter: {
            participated_as: 'performer',
        },
    });

    const closeModal = () => {
        // Ensure the modal state sets to "closed" before dispatching Current Validation to show
        flushSync(onRequestClose);

        validationDispatch({
            currentValidation,
            triggerScroll: true,
            showPopover: true,
        });
    };

    const trackDataMap: Record<string, Track> = keyBy(tracksData, 'tuid');
    const filteredInternalMatches = crossAccountOSRConflictMatches.filter(
        match => trackDataMap[match.tuid]
    );
    const totalMatches =
        filteredInternalMatches.length +
        potentialAudioInfringementMatches.length;

    const tableData: PotentialAudioInfringementModalTableData[] = [
        ...filteredInternalMatches.map(
            (match, index): PotentialAudioInfringementModalTableData => {
                const { trackName, product, participations } =
                    trackDataMap[match.tuid]!;

                const trackArtists = participations
                    .map(({ participant }) => participant?.name)
                    .filter((artist): artist is string => !!artist);

                return {
                    trackNumber: index + 1,
                    trackName: trackName || EMPTY_CHAR,
                    artistName: trackArtists || EMPTY_CHAR,
                    imprintName: product?.imprint || EMPTY_CHAR,
                    accountId: match.vendor_id.toString(),
                    distributorName: match.company_brand || EMPTY_CHAR,
                    matchType: 'internal',
                    oaTrackLink: OATrackEditPageURL(match.upc, match.tuid),
                    upc: match.upc,
                };
            }
        ),
        ...potentialAudioInfringementMatches.map(
            (match, index): PotentialAudioInfringementModalTableData => ({
                trackNumber: filteredInternalMatches.length + index + 1,
                trackName: match.title || EMPTY_CHAR,
                artistName:
                    match.artists && match.artists.length > 0
                        ? match.artists
                        : EMPTY_CHAR,
                imprintName: match.label || EMPTY_CHAR,
                accountId: null,
                distributorName:
                    match.rights_claim?.map(claim => claim.distributor.name) ??
                    EMPTY_CHAR,
                matchType: 'external',
                songwhipLinks: match?.songwhip_external_links,
            })
        ),
    ];

    return (
        <Modal
            className={CLASS_NAME}
            isOpen={isOpen}
            onRequestClose={closeModal}
            zIndex={1060}
            testId={CLASS_NAME}
        >
            <MatchesTable
                trackMetadata={trackMetadata}
                tableData={tableData}
                trackDataLoading={
                    trackDataLoading || tableData.length !== totalMatches
                }
            />
        </Modal>
    );
};

export default PotentialAudioInfringementModal;