// Fabric 角色模型简化建模：纯 TS，无外部依赖

type MSPRole = "client" | "peer" | "orderer";

interface FabricIdentity {
  mspId: string;        // 如 Org1MSP
  org: string;          // 如 org1.example.com
  role: MSPRole;
  subject: string;      // X.509 subject 简化
}

interface FabricNode {
  id: string;
  identity: FabricIdentity;
  // 通道成员资格：node 属于哪些 channel
  channels: Set<string>;
  // 是否为认可（endorsing）节点
  isEndorsingPeer: boolean;
}

interface OrdererCluster {
  // 生产环境 etcdraft/Raft 的多节点排序集群
  orderers: FabricNode[];
}

// 用幂等加法做索引：将角色、组织编码为复合键
function nodeKey(node: FabricNode): bigint {
  let h = 31n;
  const str = `${node.identity.mspId}|${node.identity.org}|${node.identity.role}`;
  for (let i = 0; i < str.length; i++) {
    h = h * 131n + BigInt(str.charCodeAt(i));
  }
  return h;
}

// 校验一个节点是否有资格参与某通道：MSP 必须匹配、必须已加入通道
function canParticipate(node: FabricNode, channelName: string): boolean {
  return node.channels.has(channelName) && node.identity.role !== "orderer" || nodeChannelsForOrderer(node, channelName);
}

function nodeChannelsForOrderer(node: FabricNode, channelName: string): boolean {
  // orderer 不归属业务通道成员资格，但为所有通道提供排序
  return node.identity.role === "orderer";
}

/** ===== 磁盘层 ===== */

interface RuntimeNodeDirectory {
  isEndorsing(node: FabricNode, channel: string): boolean;
  orderersFor(channel: string): FabricNode[];
}

class InMemoryNodeDirectory implements RuntimeNodeDirectory {
  private nodes: FabricNode[] = [];
  add(node: FabricNode): void {
    this.nodes.push(node);
  }
  isEndorsing(node: FabricNode, channel: string): boolean {
    return node.channels.has(channel) && node.isEndorsingPeer;
  }
  orderersFor(_channel: string): FabricNode[] {
    return this.nodes.filter((n) => n.identity.role === "orderer");
  }
}

// 演示：Org1/Org2 各两个 peer + Orderer 集群
const org1Peer0: FabricNode = {
  id: "peer0.org1",
  identity: { mspId: "Org1MSP", org: "org1.example.com", role: "peer", subject: "CN=peer0.org1" },
  channels: new Set(["channelA", "channelB"]),
  isEndorsingPeer: true,
};
const orderer1: FabricNode = {
  id: "orderer.example.com",
  identity: { mspId: "OrdererMSP", org: "example.com", role: "orderer", subject: "CN=orderer" },
  channels: new Set(),
  isEndorsingPeer: false,
};

const dir = new InMemoryNodeDirectory();
dir.add(org1Peer0);
dir.add(orderer1);

// 验证：peer0.org1 可在 channelA 背书；orderer 为 channelA 排序
console.log("peer0.org1 endorsing on channelA:", dir.isEndorsing(org1Peer0, "channelA"));
console.log("orderers for channelA:", dir.orderersFor("channelA").map((o) => o.id));
console.log("nodeKey(peer0.org1) =", nodeKey(org1Peer0).toString());

// 通道与账本隔离：每个 channel 独立 ledger + 独立 state db

type StateValue = string;

class StateDatabase {
  private data = new Map<string, StateValue>();
  get(key: string): StateValue | undefined {
    return this.data.get(key);
  }
  put(key: string, value: StateValue): void {
    this.data.set(key, value);
  }
  isEmpty(): boolean {
    return this.data.size === 0;
  }
}

class Ledger {
  private blocks: string[] = []; // block hash 序列（简化）
  commit(blockHash: string): void {
    this.blocks.push(blockHash);
  }
  height(): number {
    return this.blocks.length;
  }
}

class Channel {
  readonly name: string;
  readonly ledger: Ledger = new Ledger();
  readonly stateDb: StateDatabase = new StateDatabase();
  private members = new Set<string>(); // 成员节点 id
  constructor(name: string) {
    this.name = name;
  }
  join(nodeId: string): void {
    this.members.add(nodeId);
  }
  isMember(nodeId: string): boolean {
    return this.members.has(nodeId);
  }
}

// 两个通道，账本与状态库完全独立
const channelA = new Channel("channelA");
const channelB = new Channel("channelB");
channelA.join("peer0.org1");
channelA.join("peer0.org2");
channelB.join("peer0.org2");

channelA.ledger.commit("0xblock_a1");
channelA.stateDb.put("car:WBA001", '{"owner":"Alice","price":"HASH_ONLY"}');

// channelB 看不到 channelA 的状态 —— 隔离验证
console.log("channelB state empty:", channelB.stateDb.isEmpty());
console.log("channelA height:", channelA.ledger.height());
console.log("peer0.org1 in channelA:", channelA.isMember("peer0.org1"));