import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
import { Data, fromHex, toHex, UTxO } from '@lucid-evolution/lucid';

export const AssetClassSchema = Data.Object({
  currencySymbol: Data.Bytes(),
  /** Use the HEX encoding */
  tokenName: Data.Bytes(),
});
export type AssetClassD = Data.Static<typeof AssetClassSchema>;

export function toAssetClassFromLucid(asset: AssetClassD): AssetClass {
  return {
    currencySymbol: fromHex(asset.currencySymbol),
    tokenName: fromHex(asset.tokenName),
  };
}

export function getAssetClassComparisonStr(asset: AssetClass): string {
  return `${toHex(asset.currencySymbol)}${toHex(asset.tokenName)}`;
}

export const VerificationKeyHashSchema = Data.Bytes();

export const CredentialSchema = Data.Enum([
  Data.Object({
    PublicKeyCredential: Data.Tuple([VerificationKeyHashSchema]),
  }),
  Data.Object({
    ScriptCredential: Data.Tuple([Data.Bytes()]),
  }),
]);
export type CredentialD = Data.Static<typeof CredentialSchema>;
export const CredentialD = CredentialSchema as unknown as CredentialD;

export const StakeCredentialSchema = Data.Enum([
  Data.Object({ Inline: Data.Tuple([CredentialSchema]) }),
  Data.Object({
    Pointer: Data.Tuple([
      Data.Object({
        slotNumber: Data.Integer(),
        transactionIndex: Data.Integer(),
        certificateIndex: Data.Integer(),
      }),
    ]),
  }),
]);

export type StakeCredential = Data.Static<typeof StakeCredentialSchema>;
export const StakeCredential =
  StakeCredentialSchema as unknown as StakeCredential;

export type ParsedOutput<T> = { utxo: UTxO; datum: T };