import { ResetClerk } from './ResetClerk';
import type { ReadStrategy } from '../../parsing/ReadStrategy';
import { SFPToolboxErrorCode } from '../../error/error';
import type { BluetoothContextType } from '../context';
import { BluetoothProbeEmitter } from '../emitter/BluetoothProbeEmitter';
import { DummyProbeEmitter } from '../emitter/DummyProbeEmitter';

export type MockCode = string;

interface Params {
  bluetoothContext: BluetoothContextType | null;
  interval?: number;
  mockCode?: MockCode;
  onBeginResetting: any;
  onClose: Function;
  onSuccess: Function;
  readStrategy: ReadStrategy;
  resetError: Object | undefined;
}

export const resetToZero = ({
  bluetoothContext,
  interval,
  mockCode,
  onBeginResetting,
  onClose,
  onSuccess,
  readStrategy,
  resetError,
}: Params) => {
  const probeEmitter = mockCode
    ? new DummyProbeEmitter(true, interval)
    : new BluetoothProbeEmitter(bluetoothContext?.connectedDevice, bluetoothContext?.manager);

  const resetCommand =
    readStrategy.meterFamily.resetToZeroCommand && readStrategy.meterFamily.resetToZeroCommand();

  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 ResetClerk(resolve, reject, onBeginResetting, resetCommand);

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

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

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

      onClose(resetError ?? error);
    });

  return obj;
};