import React, {
  useState,
  useMemo,
  createContext,
  useCallback,
  ReactNode,
} from 'react';
import {useCookies} from 'hooks/useCookies';
import {history} from 'routing/router';
import {ROUTES} from 'routing/routes';
import {setAccessTokenToCookie} from 'helpers/setAccessTokenToCookie';
import {
  useSignUpMutation,
  useSignInMutation,
  useResendConfirmRegistrationMutation,
  useRefreshTokenMutation,
} from './api';
import {
  SignUpUserData,
  SignInUserData,
  ResendConfirmRegistrationData,
} from './types';
import {AxiosResponse} from 'axios';
import {ResponseApi} from 'services/api/types';

const AuthenticatedState = {
  IDLE: 'IDLE',
  PROCESS: 'PROCESS',
  END: 'END',
} as const;

interface AuthContextValue {
  isLoading: boolean;
  isAuthenticated: boolean;
  authenticatedState: keyof typeof AuthenticatedState;
  onLogout: VoidFunction;
  onSignIn: any;
  onResendConfirmRegistration: any;
  onSignUp: any;
  checkAuth: any;
}

const AuthContext = createContext<AuthContextValue | undefined>(undefined);

export const AuthProvider = ({children}: {children: ReactNode}) => {
  const {getCookie, removeCookie} = useCookies();

  const accessToken = getCookie('control_auto_access_token');

  const isAuthenticated = useMemo(() => Boolean(accessToken), [accessToken]);

  const [authenticatedState, setAuthenticatedState] = useState<
    keyof typeof AuthenticatedState
  >(() => (Boolean(accessToken) ? 'END' : 'IDLE'));

  const signUpMutation = useSignUpMutation();
  const signInMutation = useSignInMutation();
  const resendConfirmRegistrationMutation = useResendConfirmRegistrationMutation();
  const refreshTokenMutation = useRefreshTokenMutation();

  const handleLogout = useCallback(() => {
    removeCookie('control_auto_access_token');

    history.push(ROUTES.root());
  }, [removeCookie]);

  const handleSignIn = useCallback(
    async (signInUserData: SignInUserData) => {
      setAuthenticatedState('PROCESS');

      return await signInMutation.mutateAsync(signInUserData).finally(() => {
        setAuthenticatedState('END');
      });
    },
    [signInMutation],
  );

  const handleResendConfirmRegistration = useCallback(
    async (signUpUserData: ResendConfirmRegistrationData) => {
      return await resendConfirmRegistrationMutation.mutateAsync(
        signUpUserData,
      );
    },
    [resendConfirmRegistrationMutation],
  );

  const handleSignUp = useCallback(async (signUpUserData: SignUpUserData) => {
    return await signUpMutation.mutateAsync(signUpUserData);
  }, []);

  const handleCheckAuth = useCallback(async () => {
    if (Boolean(accessToken)) {
      return;
    }

    setAuthenticatedState('PROCESS');

    try {
      const response = await refreshTokenMutation.mutateAsync();

      setAccessTokenToCookie(response.data.result.accessToken);

      setAuthenticatedState('END');
    } catch (e) {
      setAuthenticatedState('END');
    }
  }, [accessToken, refreshTokenMutation]);

  const isLoading =
    signUpMutation.isLoading ||
    signInMutation.isLoading ||
    resendConfirmRegistrationMutation.isLoading ||
    refreshTokenMutation.isLoading;

  const value = useMemo(
    () => ({
      isLoading,
      isAuthenticated,
      authenticatedState,
      onLogout: handleLogout,
      onSignIn: handleSignIn,
      onResendConfirmRegistration: handleResendConfirmRegistration,
      onSignUp: handleSignUp,
      checkAuth: handleCheckAuth,
    }),
    [
      authenticatedState,
      handleCheckAuth,
      handleLogout,
      handleResendConfirmRegistration,
      handleSignIn,
      handleSignUp,
      isAuthenticated,
      isLoading,
    ],
  );

  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
};