import { useCallback, useRef, useState } from 'react';
import createLivenessSession from './livenessSession';
import Logger from '../../utils/logger';
import type { GetIdSdk } from '@get-id/react-native-sdk';

interface LivenessProps {
  sdk: GetIdSdk;
  onUserHintChange?: (hint: any) => void;
  onServerValidationStarted?: () => void;
  takePhoto: () => Promise<any>;
  onError: (error: any) => void;
}

export interface LivenessCommandTask {
  messageType: 'task';
  task: string;
}

export interface LivenessCommandTaskComplete {
  messageType: 'taskComplete';
}

export type LivenessWarning = {
  sessionError: string;
  warningType: string;
};
export type LivenessCommandWarning = {
  messageType: 'warning';
  warning: LivenessWarning;
  warningType: string;
};

export type LivenessError = {
  errorType: string;
  [key: string]: string;
};

export type LivenessCommandError = {
  messageType: 'failure';
  failure: LivenessError;
  errorType: string;
};

export type LivenessCommandSuccess = {
  messageType: 'success';
  artifacts: {
    fullFace: {
      fileId: string;
      signature: string;
    };
    video: {
      fileId: string;
      signature: string;
    };
  };
};

export type LivenessCommand =
  | LivenessCommandTask
  | LivenessCommandTaskComplete
  | LivenessCommandWarning
  | LivenessCommandSuccess
  | LivenessCommandError;

export type LivenessStepConfig = {
  servers: string[];
  jwt: string;
};

export const useLiveness = ({
  sdk,
  onUserHintChange,
  onServerValidationStarted,
  takePhoto,
  onError,
}: LivenessProps) => {
  const [initilising, setInitilising] = useState(false);
  const [initialised, setInitialised] = useState(false);
  const [attemptNumber, setAttemptNumber] = useState(0);

  let stop = useRef(() => {});

  const onReady = useCallback(
    (stopParam: () => {}) => {
      console.log('Liveness session ready');
      sdk.tracking.trySendEvent('liveness-preparations', 'completed');
      sdk.tracking.trySendEvent('liveness', 'started');
      setInitialised(true);
      setInitilising(false);
      stop.current = stopParam;
      onServerValidationStarted?.();
    },
    [onServerValidationStarted, sdk]
  );

  const sendLogToServer = (log: any) => {
    console.log('Log:', log);
  };

  const onCommand = useCallback(
    (command: LivenessCommand) => {
      sdk.sendLivenessEvent(command);
      onUserHintChange?.(command);
    },
    [onUserHintChange, sdk]
  );

  const init = useCallback(() => {
    const config = sdk.config.stepsConfigs.liveness as LivenessStepConfig;
    if (initilising) {
      Logger.warn('Liveness session already initialising');
      return;
    }
    if (initialised) {
      Logger.warn('Liveness session already initialised');
      return;
    }
    setInitilising(true);
    sdk.tracking.trySendEvent('liveness-preparations', 'started');
    createLivenessSession(
      config.servers,
      config.jwt,
      takePhoto,
      onCommand,
      onError,
      onReady,
      sendLogToServer,
      attemptNumber,
      setAttemptNumber
    );
  }, [
    initilising,
    initialised,
    sdk,
    takePhoto,
    onCommand,
    onReady,
    attemptNumber,
    onError,
  ]);

  return {
    init,
    stop: () => {
      setInitilising(false);
      setInitialised(false);
      stop.current();
    },
  };
};