import React, { useEffect, useState } from 'react';
import {
    Button,
    Col,
    Container,
    Form,
    Row,
} from '@theorchard/suite-components';
import { useFeatureFlag } from '@theorchard/suite-frontend';
import cx from 'classnames';
import {
    AbacusContractLifecycleSchedulePeriodType,
    AbacusContractLifecycleScheduleRenewalType,
} from 'src/apollo/definitions/globalTypes';
import { CONTRACT_LIFECYCLE_MODAL_SCREENS } from 'src/apollo/type-constants/contract';
import { CurrentPeriodFormFields } from 'src/components/contract-lifecycle-shared/current-period-form-fields';
import { contractLifecycleScheduleFormValidation } from 'src/utils/form-validations/contract-form-validation';
import { USER_FEATURES } from '../../constants';
import type {
    ContractLifecycle,
    ContractLifecycleSchedule,
} from 'src/types/abacus-contract-lifecycle';
import './styles.scss';

export interface ContractLifecycleCurrentPeriodPropTypes {
    contractLifecycle: any;
    contractLifecycleSchedules: any;
    // eslint-disable-next-line no-unused-vars
    saveHandler: (params: boolean) => void;
    // eslint-disable-next-line no-unused-vars
    setContractLifecycle: (params: ContractLifecycle) => void;
    setContractLifecycleSchedules: (
        // eslint-disable-next-line no-unused-vars
        params: ContractLifecycleSchedule[]
    ) => void;
    setServerError: (params: string | null) => void;
    // eslint-disable-next-line no-unused-vars
    setModalScreen: (params: string) => void;
    isVisible: boolean;
    isEditForm?: boolean;
}

export const ContractLifecycleCurrentPeriod: React.FC<
    ContractLifecycleCurrentPeriodPropTypes
> = ({
    contractLifecycle,
    contractLifecycleSchedules,
    saveHandler,
    setContractLifecycle,
    setContractLifecycleSchedules,
    setServerError,
    setModalScreen,
    isVisible,
    isEditForm = false,
}) => {
    const defaultFormValues: ContractLifecycleSchedule = {
        renewalType: null,
        renewalOffsetDetailInterval: null,
        renewalOffsetDetailType:
            AbacusContractLifecycleSchedulePeriodType.MONTH,
        scheduleEnd: null,
        terminationNoticeDetailInterval: null,
        terminationNoticeDetailType:
            AbacusContractLifecycleSchedulePeriodType.DAY,
    };

    const [currentSchedule, setCurrentSchedule] =
        useState<ContractLifecycleSchedule>(defaultFormValues);
    const [isSameRenewalRulesChecked, setIsSameRenewalRulesChecked] =
        useState<boolean>(true);
    const [errors, setErrors] = useState<
        Partial<ContractLifecycle> & Partial<ContractLifecycleSchedule>
    >({});
    const [isSavingContract, setIsSavingContract] = useState(false);
    const isFeatureEditContractCurrentPeriodStartEnabled = useFeatureFlag(
        USER_FEATURES.ABACUS_CONTRACT_EDIT_CURRENT_PERIOD_START_DATE
    );

    const handleBackButtonClick = () => {
        setServerError(null);
        setIsSavingContract(false);
        setModalScreen(CONTRACT_LIFECYCLE_MODAL_SCREENS.GENERAL_INFORMATION);
    };

    const handleCreateButtonClick = () => {
        setIsSavingContract(true);
        const validationErrors = contractLifecycleScheduleFormValidation(
            currentSchedule,
            contractLifecycle.lifecycleTermStart,
            isFeatureEditContractCurrentPeriodStartEnabled
        );

        if (Object.keys(validationErrors).length > 0) {
            setErrors(validationErrors);
            return;
        }
        saveHandler(isSameRenewalRulesChecked);
    };

    const handleNextButtonClick = () => {
        const validationErrors = contractLifecycleScheduleFormValidation(
            currentSchedule,
            contractLifecycle.lifecycleTermStart,
            isFeatureEditContractCurrentPeriodStartEnabled
        );

        if (Object.keys(validationErrors).length > 0) {
            setErrors(validationErrors);
            return;
        }

        setModalScreen(CONTRACT_LIFECYCLE_MODAL_SCREENS.SUBSEQUENT_PERIOD);
    };

    const isCreateButtonDisabled = () => {
        if (isSavingContract) return true;
        if (
            !isFeatureEditContractCurrentPeriodStartEnabled &&
            !contractLifecycle.lifecycleTermStart
        )
            return true;

        switch (currentSchedule.renewalType) {
            case AbacusContractLifecycleScheduleRenewalType.CONTINUOUSLY_ACTIVE:
                return !currentSchedule.terminationNoticeDetailInterval;
            case AbacusContractLifecycleScheduleRenewalType.RENEW_PERIODICALLY:
                return (
                    !currentSchedule.terminationNoticeDetailInterval ||
                    !currentSchedule.renewalOffsetDetailInterval
                );
            default:
                return !isFeatureEditContractCurrentPeriodStartEnabled;
        }
    };

    const isNextButtonDisabled = () => {
        if (
            !isFeatureEditContractCurrentPeriodStartEnabled &&
            !contractLifecycle.lifecycleTermStart
        )
            return true;

        switch (currentSchedule.renewalType) {
            case AbacusContractLifecycleScheduleRenewalType.RENEW_AFTER_CERTAIN_DATE:
                return (
                    !currentSchedule.terminationNoticeDetailInterval ||
                    !currentSchedule.scheduleEnd
                );
            case AbacusContractLifecycleScheduleRenewalType.RENEW_PERIODICALLY:
                return (
                    !currentSchedule.terminationNoticeDetailInterval ||
                    !currentSchedule.renewalOffsetDetailInterval
                );
            default:
                return !isFeatureEditContractCurrentPeriodStartEnabled;
        }
    };

    useEffect(() => {
        contractLifecycleSchedules[0] &&
            setCurrentSchedule(contractLifecycleSchedules[0]);
    }, [contractLifecycleSchedules]);

    const renderFooterButton = () => {
        if (
            currentSchedule.renewalType ===
                AbacusContractLifecycleScheduleRenewalType.CONTINUOUSLY_ACTIVE ||
            (currentSchedule.renewalType ===
                AbacusContractLifecycleScheduleRenewalType.RENEW_PERIODICALLY &&
                isSameRenewalRulesChecked)
        )
            return (
                <Button
                    data-testid="create-button"
                    disabled={isCreateButtonDisabled()}
                    onClick={handleCreateButtonClick}
                    variant="primary"
                >
                    Create
                </Button>
            );

        return (
            <Button
                data-testid="next-button"
                disabled={isNextButtonDisabled()}
                onClick={() => handleNextButtonClick()}
                variant="primary"
            >
                Next
            </Button>
        );
    };

    return (
        <Container
            className={cx('ContractLifecycleFullScreenModal-Container', {
                visible: isVisible,
            })}
        >
            <Form>
                <CurrentPeriodFormFields
                    isEditForm={isEditForm}
                    contractLifecycle={contractLifecycle}
                    currentSchedule={currentSchedule}
                    defaultFormValues={defaultFormValues}
                    errors={errors}
                    isSameRenewalRulesChecked={isSameRenewalRulesChecked}
                    setContractLifecycle={setContractLifecycle}
                    setContractLifecycleSchedules={
                        setContractLifecycleSchedules
                    }
                    setErrors={setErrors}
                    setIsSameRenewalRulesChecked={setIsSameRenewalRulesChecked}
                    subsequentSchedule={
                        contractLifecycleSchedules.length > 1
                            ? contractLifecycleSchedules[1]
                            : null
                    }
                />
                <div className="ContractLifecycleFullScreenModal-Footer">
                    <Row>
                        <Col>
                            <Button
                                onClick={() => handleBackButtonClick()}
                                variant="quartenary"
                            >
                                Back
                            </Button>
                        </Col>
                        <Col>{renderFooterButton()}</Col>
                    </Row>
                </div>
            </Form>
        </Container>
    );
};