Royalty Payments Flow

import { CulturaSDK, ParentInfo } from "@cultura/sdk";
import { parseEther, getAddress } from "viem";

// --- Step 1: Register Royalty Due (Optional) ---
async function registerDue(sdk: CulturaSDK) {
  try {
    const startDate = BigInt(Math.floor(Date.now() / 1000));
    const endDate = startDate + 30n * 24n * 60n * 60n; // 30 days later
    console.log(`Registering royalty due for period ${periodIndex}...`);
    const txHash = await sdk.royalty.registerRoyaltyDue(
      licensedAssetId,
      totalRoyaltyAmount,
      startDate,
      endDate,
      periodIndex
    );
    await sdk.publicClient.waitForTransactionReceipt({ hash: txHash });
    console.log("Royalty due registered:", txHash);
  } catch (e) {
    console.error("Error registering royalty due:", e);
  }
}

// --- Step 2: Sponsored Payment Flow ---
async function sponsoredPaymentFlow(
  licenseeSdk: CulturaSDK,
  sponsorSdk: CulturaSDK,
  sponsorAddress: `0x${string}`,
  licenseeAddress: `0x${string}`
) {
  try {
    // 2a: Sponsor approves VR RBA to spend tokens
    console.log(
      `Sponsor approving VR RBA ${vrRbaAddress} to spend ${totalRoyaltyAmount}...`
    );
    const approveTx = await sponsorSdk.bondToken.approve(
      vrRbaAddress,
      totalRoyaltyAmount
    );
    await sponsorSdk.publicClient.waitForTransactionReceipt({
      hash: approveTx,
    });
    console.log("VR RBA approved by sponsor.");

    // 2b: Licensee signs payment authorization with sponsor
    console.log("Licensee signing payment authorization...");
    licenseeSdk.setRightsBoundAccount(vrRbaAddress);
    const paymentSignature =
      await licenseeSdk.rightsBoundAccount.signForSetPaymentInfo(
        periodIndex,
        totalRoyaltyAmount,
        sponsorAddress
      );
    console.log("Payment signature obtained from licensee.");

    // 2c: Sponsor executes payment
    console.log("Sponsor executing payment to VR RBA...");
    sponsorSdk.setRightsBoundAccount(vrRbaAddress);
    await sponsorSdk.rightsBoundAccount.setPaymentInfo({
      totalAmount: totalRoyaltyAmount,
      sponsor: sponsorAddress,
      signature: paymentSignature,
      signer: licenseeAddress,
    });
    console.log("Payment executed successfully by sponsor.");
  } catch (e) {
    console.error("Error in sponsored payment flow:", e);
    throw e;
  }
}

// --- Step 3: Parent Claims from Child (VR RBA) ---
async function parentClaimsFromChild(
  sdk: CulturaSDK,
  parentRbaAddress: `0x${string}`
) {
  try {
    sdk.setRightsBoundAccount(parentRbaAddress);
    console.log(
      `Parent claiming from child VR RBA for period ${periodIndex}...`
    );
    const claimTx = await sdk.rightsBoundAccount.claimFromChild(
      vrRbaAddress,
      periodIndex
    );
    await sdk.publicClient.waitForTransactionReceipt({ hash: claimTx });
    console.log("Parent successfully claimed from child VR RBA.");
  } catch (e) {
    console.error("Error claiming from child:", e);
    throw e;
  }
}

// --- Step 4: Parent Owner Claims from Parent RBA ---
async function claimFromParentRba(
  sdk: CulturaSDK,
  parentRbaAddress: `0x${string}`
) {
  try {
    sdk.setRightsBoundAccount(parentRbaAddress);
    console.log(`Parent owner claiming from parent RBA for period 0...`);
    // Parent RBA period will be 0 after claiming from child
    const claimTx = await sdk.rightsBoundAccount.claim(0n);
    await sdk.publicClient.waitForTransactionReceipt({ hash: claimTx });
    console.log("Parent owner claimed from parent RBA.");
  } catch (e) {
    console.error("Error claiming from parent RBA:", e);
    if (e.message.includes("NothingToClaim")) {
      console.warn("Parent share already claimed or not available.");
    } else {
      throw e;
    }
  }
}

// --- Step 5: Verifier Rewards Distribution ---
async function distributeVerifierRewards(
  sdk: CulturaSDK,
  parentAssetId: bigint,
  parentRbaAddress: `0x${string}`
) {
  try {
    console.log(`Distributing verifier rewards for parent ${parentAssetId}...`);
    const distributeTx = await sdk.verifierModule.distributeRewards(
      assetContractAddress,
      parentAssetId,
      parentRbaAddress,
      0n // Parent RBA period after claiming from child
    );
    await sdk.publicClient.waitForTransactionReceipt({ hash: distributeTx });
    console.log("Verifier rewards distributed to VerifierModule.");
  } catch (e) {
    console.error("Error distributing verifier rewards:", e);
    throw e;
  }
}

// --- Step 6: Individual Verifier Claims ---
async function claimVerifierReward(sdk: CulturaSDK, parentAssetId: bigint) {
  try {
    const verifierAddress = sdk.walletClient!.account!.address;
    const claimable = await sdk.verifierModule.calculateClaimableRewards(
      assetContractAddress,
      parentAssetId,
      verifierAddress
    );
    console.log(
      `Verifier claimable amount for parent ${parentAssetId}: ${claimable}`
    );

    if (claimable > 0n) {
      console.log("Verifier claiming rewards...");
      const claimTx = await sdk.verifierModule.claimRewards(
        assetContractAddress,
        parentAssetId
      );
      await sdk.publicClient.waitForTransactionReceipt({ hash: claimTx });
      console.log("Verifier rewards claimed.");
    } else {
      console.log("No rewards available to claim.");
    }
  } catch (e) {
    console.error("Error claiming verifier reward:", e);
    throw e;
  }
}

// --- Off-Chain Payment Flow ---
async function offChainPaymentFlow(
  licenseeSdk: CulturaSDK,
  parentOwnerSdk: CulturaSDK,
  sponsorSdk: CulturaSDK,
  sponsorAddress: `0x${string}`,
  licenseeAddress: `0x${string}`,
  parentOwnerAddress: `0x${string}`
) {
  try {
    // Step 1: Register off-chain royalty period (delegated)
    console.log("Registering off-chain royalty period...");
    const offchainRoyaltyDue = parseEther("5");
    const startDate = BigInt(Math.floor(Date.now() / 1000));
    const endDate = startDate + BigInt(365 * 24 * 60 * 60);
    const offchainPeriodIndex =
      await licenseeSdk.royalty.getRoyaltyInfoCount(licensedAssetId);

    const registrationSignature =
      await licenseeSdk.royalty.signForDelegatedRegisterRoyaltyDue(
        licensedAssetId,
        offchainRoyaltyDue,
        startDate,
        endDate,
        offchainPeriodIndex
      );

    await sponsorSdk.royalty.delegatedRegisterRoyaltyDue(
      licensedAssetId,
      offchainRoyaltyDue,
      startDate,
      endDate,
      offchainPeriodIndex,
      registrationSignature
    );
    console.log("Off-chain royalty period registered.");

    // Step 2: Report off-chain payment (delegated)
    console.log("Reporting off-chain payment...");
    const paymentAmount = parseEther("1");
    const paymentMetadata = JSON.stringify({
      paymentMethod: "Bank Transfer",
      referenceNumber: "BT-2023-12345",
      paymentDate: new Date().toISOString(),
      notes: "Payment for Q3 licensing",
    });

    const reportSignature =
      await licenseeSdk.royalty.signForDelegatedOffchainReportRoyalty(
        licensedAssetId,
        offchainPeriodIndex,
        paymentAmount
      );

    await sponsorSdk.royalty.delegatedReportOffChainPayment(
      licensedAssetId,
      offchainPeriodIndex,
      paymentAmount,
      paymentMetadata,
      reportSignature
    );
    console.log("Off-chain payment reported.");

    // Step 3: Parent acceptance (sponsored fees)
    console.log("Parent accepting off-chain payment...");

    // Get parent's allocated amount
    const parentAcceptanceInfo =
      await licenseeSdk.royalty.getParentAcceptanceInfo(
        licensedAssetId,
        offchainPeriodIndex,
        parent1RbaAddress
      );
    const allocatedAmount = parentAcceptanceInfo.allocatedAmount;

    if (allocatedAmount > 0n) {
      // Parent owner signs acceptance
      const acceptSignature =
        await parentOwnerSdk.royalty.signForAcceptOffChainPaymentByParent(
          parent1RbaAddress,
          allocatedAmount,
          offchainPeriodIndex,
          sponsorAddress
        );

      // Sponsor executes acceptance (paying fees)
      await sponsorSdk.royalty.acceptOffChainPaymentByParent(
        licensedAssetId,
        offchainPeriodIndex,
        parent1RbaAddress,
        acceptSignature,
        parentOwnerAddress,
        sponsorAddress
      );
      console.log("Off-chain payment accepted by parent.");
    }

    // Step 4: Check acceptance status
    const allParentInfo = await licenseeSdk.royalty.getAllParentAcceptanceInfo(
      licensedAssetId,
      offchainPeriodIndex,
      assetContractAddress
    );

    console.log("Parent acceptance statuses:");
    for (const parentInfo of allParentInfo) {
      console.log(`- Parent RBA: ${parentInfo.parentBoundAccount}`);
      console.log(`  Status: ${parentInfo.acceptanceInfo.status}`);
      console.log(`  Amount: ${parentInfo.acceptanceInfo.allocatedAmount}`);
    }
  } catch (e) {
    console.error("Error in off-chain payment flow:", e);
    throw e;
  }
}

// --- Alternative: Parent Denial Flow ---
async function denyOffChainPayment(
  parentOwnerSdk: CulturaSDK,
  sponsorSdk: CulturaSDK,
  parentOwnerAddress: `0x${string}`,
  parentRbaAddress: `0x${string}`,
  periodIndex: bigint
) {
  try {
    console.log("Parent denying off-chain payment...");

    const denySignature =
      await parentOwnerSdk.royalty.signForDenyOffChainPaymentByParent(
        licensedAssetId,
        periodIndex,
        parentRbaAddress
      );

    await sponsorSdk.royalty.denyOffChainPaymentByParent(
      licensedAssetId,
      periodIndex,
      parentRbaAddress,
      denySignature,
      parentOwnerAddress
    );
    console.log("Off-chain payment denied by parent.");
  } catch (e) {
    console.error("Error denying off-chain payment:", e);
    throw e;
  }
}