import React, { useEffect, useState } from 'react';
import { Form, Formik, FormikHelpers } from 'formik';
import { object, string } from 'yup';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { faPlus } from '@fortawesome/free-solid-svg-icons';
import createServerDatabase from './api/createServerDatabase';
import { ServerDatabase } from './api/getServerDatabases';
import getDatabaseProviders, { DatabaseProviderOption } from './api/getDatabaseProviders';
import { ServerContext } from '@/state/server';
import { httpErrorToHuman } from '@/api/http';
import FlashMessageRender from '@/components/FlashMessageRender';
import Field from '@/components/elements/Field';
import Label from '@/components/elements/Label';
import Select from '@/components/elements/Select';
import useFlash from '@/plugins/useFlash';
import { Dialog } from '@/components/elements/dialog';
import { Button } from '@/components/elements/button';
import tw from 'twin.macro';

interface Values {
    providerId: string;
    databaseName: string;
    connectionsFrom: string;
}

const FORM_ID = 'create_database_form';

const schema = object().shape({
    providerId: string().required('A database provider must be selected.'),
        databaseName: string()
            .required('A database name must be provided.')
            .min(3, 'Database name must be at least 3 characters.')
            .max(31, 'Database name must not exceed 31 characters.')
            .matches(
            /^[A-Za-z0-9_]{3,31}$/,
            'Database name should only contain alphanumeric characters and underscores.'
        ),
    connectionsFrom: string().matches(/^[\w\-/.%:]+$/, 'A valid host address must be provided.'),
});

export default ({ className, onCreated }: { className?: string; onCreated?: (database: ServerDatabase) => void }) => {
    const uuid = ServerContext.useStoreState((state) => state.server.data!.uuid);
    const { addError, clearFlashes } = useFlash();
    const [open, setOpen] = useState(false);
    const [providers, setProviders] = useState<DatabaseProviderOption[]>([]);
    const [loadingProviders, setLoadingProviders] = useState(false);

    const createProviders = providers.filter((provider) => provider.canCreate);

    useEffect(() => {
        if (!open) {
            return;
        }

        setLoadingProviders(true);
        getDatabaseProviders(uuid)
            .then((providers) => setProviders(providers))
            .catch((error) => addError({ key: 'database:create', message: httpErrorToHuman(error) }))
            .then(() => setLoadingProviders(false));
    }, [open]);

    const submit = (values: Values, { resetForm, setSubmitting }: FormikHelpers<Values>) => {
        clearFlashes('database:create');
        createServerDatabase(uuid, {
            databaseName: values.databaseName,
            connectionsFrom: values.connectionsFrom || '%',
            providerId: values.providerId,
        })
            .then((database) => {
                onCreated && onCreated(database);
                resetForm();
                setSubmitting(false);
                setOpen(false);
            })
            .catch((error) => {
                addError({ key: 'database:create', message: httpErrorToHuman(error) });
                setSubmitting(false);
            });
    };

    return (
        <>
            <Formik
                onSubmit={submit}
                initialValues={{
                    providerId: createProviders[0]?.id || '',
                    databaseName: '',
                    connectionsFrom: '',
                }}
                enableReinitialize
                validationSchema={schema}
            >
                {({ isSubmitting, resetForm, values, setFieldValue, errors, touched }) => (
                    <Dialog
                        open={open}
                        title={'Create database'}
                        preventExternalClose={isSubmitting}
                        onClose={() => {
                            if (isSubmitting) {
                                return;
                            }

                            resetForm();
                            setOpen(false);
                        }}
                    >
                        <FlashMessageRender byKey={'database:create'} css={tw`mb-5`} />
                        <Form id={FORM_ID} css={tw`m-0`}>
                            <div css={tw`mb-5`}>
                                <Label htmlFor={'database_provider'}>Provider</Label>
                                <Select
                                    id={'database_provider'}
                                    name={'providerId'}
                                    value={values.providerId}
                                    disabled={isSubmitting || loadingProviders || createProviders.length === 0}
                                    onChange={(event) => setFieldValue('providerId', event.currentTarget.value)}
                                >
                                    {loadingProviders ? (
                                        <option value={''}>Loading providers...</option>
                                    ) : createProviders.length > 0 ? (
                                        createProviders.map((provider) => (
                                            <option key={provider.id} value={provider.id}>
                                                {provider.name} - {provider.engine.toUpperCase()} - {provider.endpoint}
                                            </option>
                                        ))
                                    ) : (
                                        <option value={''}>No available database providers</option>
                                    )}
                                </Select>
                                {touched.providerId && errors.providerId ? (
                                    <p className={'input-help error'}>{errors.providerId}</p>
                                ) : null}
                            </div>
                            <Field
                                type={'string'}
                                id={'database_name'}
                                name={'databaseName'}
                                label={'Name'}
                            />
                            <div css={tw`mt-5`}>
                                <Field
                                    type={'string'}
                                    id={'connections_from'}
                                    name={'connectionsFrom'}
                                    label={'Remote'}
                                    placeholder={'%'}
                                />
                            </div>
                            <Dialog.Footer>
                                <Button.Text type={'button'} disabled={isSubmitting} onClick={() => setOpen(false)}>
                                    Cancel
                                </Button.Text>
                                <Button
                                    type={'submit'}
                                    form={FORM_ID}
                                    disabled={isSubmitting || createProviders.length === 0}
                                >
                                    Create Database
                                </Button>
                            </Dialog.Footer>
                        </Form>
                    </Dialog>
                )}
            </Formik>

            <Button type={'button'} className={className} onClick={() => setOpen(true)}>
                <FontAwesomeIcon icon={faPlus} css={tw`mr-2`} />
                New database
            </Button>
        </>
    );
};