/**
 * 去中心化数据市场的核心数据授权与计费系统（零外部依赖纯 TypeScript 实现）
 * 核心抽象：DataOwner 管理 DataAsset，通过 AccessToken 实现按次授权与自动结算
 */

class Address {
  constructor(public value: string) {}
  toString() { return this.value; }
  equals(other: Address) { return this.value === other.value; }
}

class DataAsset {
  constructor(
    public id: string,
    public owner: Address,
    public metadataHash: string,      // 数据元信息哈希（如 IPFS CID）
    public description: string,
    public basePrice: bigint,         // 每次访问的基础费用（wei 单位）
    public totalAccessCount: number = 0,
    public cumulativeRevenue: bigint = 0n
  ) {}
}

class AccessToken {
  constructor(
    public tokenId: string,
    public assetId: string,
    public consumer: Address,
    public maxUses: number,           // 最大可用次数（类似授额）
    public remainingUses: number,
    public grantedAt: number,         // 时间戳
    public expiresAt: number,
    public isValid: boolean = true
  ) {}
}

class DataMarketCore {
  assets: Map<string, DataAsset> = new Map();
  accessTokens: Map<string, AccessToken> = new Map();
  tokenCounter = 0;

  registerAsset(
    from: Address,
    id: string,
    metadataHash: string,
    description: string,
    basePrice: bigint
  ): DataAsset {
    if (this.assets.has(id)) throw new Error(`Asset ${id} already exists`);
    const asset = new DataAsset(id, from, metadataHash, description, basePrice);
    this.assets.set(id, asset);
    return asset;
  }

  validateAccess(
    assetId: string,
    tokenId: string,
    consumer: Address,
    now: number
  ): boolean {
    const asset = this.assets.get(assetId);
    const token = this.accessTokens.get(tokenId);
    if (!asset || !token) return false;
    if (token.assetId !== assetId) return false;
    if (!token.consumer.equals(consumer)) return false;
    if (!token.isValid) return false;
    if (token.remainingUses <= 0) return false;
    if (now > token.expiresAt) return false;
    return true;
  }

  createAccessToken(
    assetId: string,
    consumer: Address,
    maxUses: number,
    now: number,
    duration: number,
    value: bigint
  ): AccessToken {
    const asset = this.assets.get(assetId);
    if (!asset) throw new Error('Asset not found');

    // 模拟链上检查：消费者支付的金额必须 >= 预估所需
    const required = asset.basePrice * BigInt(maxUses);
    if (value < required) throw new Error(`Payment insufficient: ${value} <${required}`);

    this.tokenCounter++;
    const tokenId = `TK-${assetId}-${this.tokenCounter}`;
    const token = new AccessToken(
      tokenId, assetId, consumer, maxUses, maxUses,
      now, now + duration
    );
    this.accessTokens.set(tokenId, token);
    return token;
  }

  consumeAccess(tokenId: string, now: number, consumer: Address): void {
    const token = this.accessTokens.get(tokenId);
    if (!token) throw new Error('Token not found');
    if (!token.isValid) throw new Error('Token already consumed or revoked');
    if (token.remainingUses <= 0) throw new Error('Token uses exhausted');
    if (now > token.expiresAt) throw new Error('Token expired');
    if (!token.consumer.equals(consumer)) throw new Error('Token ownership mismatch');

    // 原子扣减：剩余次数 -1，同时累加到资产持有者的收入
    const asset = this.assets.get(token.assetId)!;
    token.remainingUses--;
    asset.totalAccessCount++;
    asset.cumulativeRevenue += asset.basePrice;

    // 模拟：如果剩余次数为0则自动作废
    if (token.remainingUses === 0) {
      token.isValid = false;
    }
  }
}

// ======== 端到端演示 ========
const market = new DataMarketCore();

const alice = new Address('0xALICE');
const bob = new Address('0xBOB');

// 1. Alice 注册一个医学影像数据集
const dataset = market.registerAsset(
  alice,
  'MED-IMG-001',
  'QmHash123...',
  '匿名胸部 CT 扫描（10k 张）',
  1000n // 每次访问 1000 wei
);

// 2. Bob 购买 100 次访问额，支付 1000 * 100 = 100000 wei 价值
const token = market.createAccessToken(
  dataset.id, bob, 100, 1700000000, 86400, 100000n
);

// 3. Bob 使用 1 次
market.consumeAccess(token.tokenId, 1700000010, bob);

// 4. Alice 的收益自动累积
console.log(`Asset revenue: ${dataset.cumulativeRevenue} wei`); // 1000
console.log(`Remaining uses: ${token.remainingUses}`); // 99
console.log(`Valid: ${market.validateAccess(dataset.id, token.tokenId, bob, 1700000010)}`); // true