import React, {useCallback, useEffect, useRef} from 'react'
import PropTypes from 'prop-types'
import {connect} from 'react-redux'
import {bindActionCreators} from 'redux'
import hoistNonReactStatics from 'hoist-non-react-statics'
import {
    errorForm,
    registerForm,
    unregisterForm,
    updateForm,
    validateForm,
} from 'store/actions'
import {getForms} from 'store/selectors'

const connectForm = (Component, mapStateToProps, mapDispatchToProps) => {
    const ConnectedForm = (props) => {
        const {
            errorForm,
            forms,
            onChange,
            onError,
            onValid,
            registerForm,
            unregisterForm,
            unregisterOnExit,
            updateForm,
            validateForm,
            ...rest
        } = props

        const form = useRef()
        const formName = useCallback(
            () => form.current?.formName || Component.formName,
            []
        )
        const formState = forms[formName()]

        useEffect(() => {
            registerForm({
                name: formName(),
                initialState: form.current?.initialState,
            })
            return () => {
                unregisterOnExit && unregisterForm({name: formName()})
            }
        }, [formName, registerForm, unregisterOnExit, unregisterForm])

        const handleChange = useCallback(
            (data) => {
                updateForm?.({name: formName(), data})
                onChange?.(data)
            },
            [formName, updateForm, onChange]
        )

        const handleError = useCallback(
            (error) => {
                errorForm?.({name: formName(), error})
                onError?.(error)
            },
            [formName, errorForm, onError]
        )

        const handleValidCheck = useCallback(
            (valid) => {
                validateForm?.({name: formName(), valid})
                onValid?.(valid)
            },
            [formName, validateForm, onValid]
        )

        if (typeof formName() !== 'string') {
            throw new TypeError(
                `Expected ${
                    Component.displayName || Component.name
                }.formName to be of type string.`
            )
        }

        return (
            <Component
                {...rest}
                {...formState}
                ref={form}
                onChange={handleChange}
                onError={handleError}
                onValid={handleValidCheck}
            />
        )
    }

    ConnectedForm.propTypes = {
        ...Component.propTypes,
        errorForm: PropTypes.func,
        registerForm: PropTypes.func,
        unregisterForm: PropTypes.func,
        unregisterOnExit: PropTypes.bool,
        updateForm: PropTypes.func,
        onChange: PropTypes.func,
        onError: PropTypes.func,
        onValid: PropTypes.func,
    }

    ConnectedForm.displayName = `connected(${
        Component.displayName || Component.name
    })`

    const selectors = (state, props) => {
        let mappedProps = {}

        if (typeof mapStateToProps === 'function') {
            mappedProps = {...mapStateToProps(state, props)}
        }

        mappedProps = {
            ...mappedProps,
            forms: getForms(state),
        }

        return mappedProps
    }

    const actionDispatchers = (dispatch) => {
        let dispatchers = {}

        if (typeof mapDispatchToProps === 'function') {
            dispatchers = {...mapDispatchToProps(dispatch)}
        }

        dispatchers = {
            ...dispatchers,
            ...bindActionCreators(
                {
                    errorForm,
                    registerForm,
                    unregisterForm,
                    updateForm,
                    validateForm,
                },
                dispatch
            ),
        }

        return dispatchers
    }

    return connect(
        selectors,
        actionDispatchers
    )(hoistNonReactStatics(ConnectedForm, Component))
}

export default connectForm
