import type {
  DeviceRegistration,
  DeviceRegistrationManifest,
} from '../../../domain/device-registration-manifest.js'
import type { Result } from '../../../framework/types/result.js'
import type { GatherDeviceInformationError } from '../../../services/device/gather.js'
import type { Services } from '../../../services/mod.js'
import type {
  DeregisterDeviceClientError,
  DeregisterDevicePlatformError,
  DeviceIsAlreadyDeregisteredError,
} from '../../../services/platform/licensing/deregister-device/errors.js'

import { DeviceRegistrationError } from '../../../services/platform/licensing/ensure-device/errors.js'

import { decodeDeviceRegistrationManifest } from '../../../domain/device-registration-manifest.js'
import { decodeJson } from '../../../framework/json/mod.js'
import {
  isError,
  makeError,
  makeSuccess,
  unwrapResult,
} from '../../../framework/types/result.js'

interface Options {
  deps: {
    services: Services
  }
}

export interface DeregisterDeviceDto {
  manifest: DeviceRegistrationManifest
}

export function buildDeregister(options: Options) {
  return async function deregister(
    dto: DeregisterDeviceDto,
  ): Promise<Result<DeregisterDeviceError, boolean>> {
    const {
      deps: { services },
    } = options

    const decodeDeviceRegistrationManifestResult =
      decodeDeviceRegistrationManifest(dto.manifest)

    if (isError(decodeDeviceRegistrationManifestResult)) {
      return makeError(
        new DeviceRegistrationError(
          'Unable to ensure the device integrity, because the given registration manifest is malformed',
        ),
      )
    }

    const gatherResult = await services.device.gather()

    if (isError(gatherResult)) {
      return gatherResult
    }

    const device = unwrapResult(gatherResult)

    const manifest = unwrapResult(decodeDeviceRegistrationManifestResult)

    const resultOfDecryptingDeviceRegistration = await services.crypto.decrypt({
      privateJwk: manifest.encryption.keypair.privateKey,
      encryptedContents: manifest.registration,
    })

    if (isError(resultOfDecryptingDeviceRegistration)) {
      return makeError(
        new DeviceRegistrationError(
          'Unable to ensure the device integrity, because the given registration manifest is malformed',
        ),
      )
    }

    const jsonEncodedDeviceRegistration = unwrapResult(
      resultOfDecryptingDeviceRegistration,
    )

    const resultOfDecodingDeviceRegistration = decodeJson<DeviceRegistration>(
      jsonEncodedDeviceRegistration,
    )

    if (isError(resultOfDecodingDeviceRegistration)) {
      return makeError(
        new DeviceRegistrationError(
          'Unable to ensure the device integrity, because the given registration manifest is malformed',
        ),
      )
    }

    const deviceRegistration = unwrapResult(resultOfDecodingDeviceRegistration)

    const deregisterResult = await services.platform.licensing.deregisterDevice(
      {
        device: {
          id: deviceRegistration.device.id,
          fingerprint: device.fingerprint,
        },
      },
    )

    if (isError(deregisterResult)) {
      return deregisterResult
    }

    return makeSuccess(deregisterResult.value)
  }
}

export type DeregisterDeviceError =
  | GatherDeviceInformationError
  | DeviceRegistrationError
  | DeregisterDeviceClientError
  | DeregisterDevicePlatformError
  | DeviceIsAlreadyDeregisteredError