import { createErrorFromCode, SFPToolboxErrorCode } from '../../error/error';
import { ChangeTimeClerk } from './ChangeTimeClerk';
import type { BluetoothContextType } from '../context';
import { BluetoothProbeEmitter } from '../emitter/BluetoothProbeEmitter';
import { DummyProbeEmitter } from '../emitter/DummyProbeEmitter';

export type MockCode = string;

interface Params {
  bluetoothContext: BluetoothContextType | null;
  mockCode?: MockCode;
  onSuccess?: any;
  onError?: any;
  onBeginReading: any;
  probeCommand: string;
  interval?: number;
}

export const changeDatetime = ({
  mockCode,
  bluetoothContext,
  onBeginReading,
  onSuccess,
  onError,
  probeCommand,
  interval,
}: Params) => {
  const probeEmitter = mockCode
    ? new DummyProbeEmitter(true, interval)
    : new BluetoothProbeEmitter(bluetoothContext?.connectedDevice, bluetoothContext?.manager);

  const obj: {
    unsubscribe: Function;
    run: Function;
    promise: null | Promise<void>;
    probeEmitter: DummyProbeEmitter | BluetoothProbeEmitter;
  } = {
    probeEmitter,
    unsubscribe: function () {
      this.probeEmitter.error({
        code: SFPToolboxErrorCode.OperationCancelled,
        message: 'Operation was cancelled',
      });
    },
    run: async function () {
      await bluetoothContext?.mutex.acquire();

      return new Promise((resolve, reject) => {
        try {
          const clerk = new ChangeTimeClerk(resolve, reject, onBeginReading);

          this.probeEmitter.subscribe(clerk);
          this.probeEmitter.start(probeCommand, mockCode);
        } catch (error: any) {
          reject(createErrorFromCode(SFPToolboxErrorCode.Unknown));
        }
      });
    },
    promise: null,
  };

  obj.promise = obj
    .run()
    .then(result => {
      bluetoothContext?.mutex.release();

      onSuccess(result);
    })
    .catch(error => {
      bluetoothContext?.mutex.release();

      onError(error);
    });

  return obj;
};