const crypto = require('crypto');
const fs = require('fs');

// 读取视频文件
function calculateVideoHash(filePath) {
    const fileBuffer = fs.readFileSync(filePath);
    // 使用 SHA-256 算法生成哈希值
    const hashSum = crypto.createHash('sha256');
    hashSum.update(fileBuffer);
    return '0x' + hashSum.digest('hex');
}

// 示例：对一段AI生成的视频进行哈希
const videoHash = calculateVideoHash('./ai_generated_video_001.mp4');
console.log('视频哈希值:', videoHash);
// 输出类似：0x8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92

const { Web3 } = require('web3');
const axios = require('axios');

// 连接Polygon网络（使用Infura或Alchemy等节点服务）
const web3 = new Web3('https://polygon-rpc.com');

// 你的钱包私钥（注意：在生产环境中请使用环境变量或硬件钱包）
const privateKey = 'YOUR_PRIVATE_KEY';
const account = web3.eth.accounts.privateKeyToAccount(privateKey);

// 确权智能合约ABI（简化版）
const rightsContractABI = [
    {
        "inputs": [
            {"name": "_contentHash", "type": "string"},
            {"name": "_metadata", "type": "string"},
            {"name": "_contentType", "type": "string"}
        ],
        "name": "registerContent",
        "outputs": [{"name": "", "type": "uint256"}],
        "type": "function"
    }
];

// 确权合约地址（示例）
const rightsContractAddress = '0x1234567890abcdef1234567890abcdef12345678';

// 创建合约实例
const rightsContract = new web3.eth.Contract(
    rightsContractABI,
    rightsContractAddress
);

// 准备元数据（JSON格式，包含生成时间、AI模型版本、提示词等信息）
const metadata = JSON.stringify({
    "timestamp": Date.now(),
    "ai_model": "Sora-2026-Pro",
    "prompt": "A cinematic shot of a lone astronaut...",
    "duration": 15,
    "resolution": "1920x1080",
    "creator": "AI-Lab-001"
});

// 构建交易
async function registerVideoRights(videoHash, metadata) {
    const tx = rightsContract.methods.registerContent(
        videoHash,
        metadata,
        'video/mp4'
    );

    const gas = await tx.estimateGas({ from: account.address });
    const gasPrice = await web3.eth.getGasPrice();

    const signedTx = await web3.eth.accounts.signTransaction(
        {
            to: rightsContractAddress,
            data: tx.encodeABI(),
            gas: gas,
            gasPrice: gasPrice,
            chainId: 137  // Polygon主网Chain ID
        },
        privateKey
    );

    const receipt = await web3.eth.sendSignedTransaction(signedTx.rawTransaction);
    return receipt;
}

// 执行确权
registerVideoRights(videoHash, metadata)
    .then(receipt => {
        console.log('确权成功！交易哈希:', receipt.transactionHash);
        console.log('区块高度:', receipt.blockNumber);
    })
    .catch(err => {
        console.error('确权失败:', err);
    });

// 查询某段视频的确权信息
async function verifyVideoRights(videoHash) {
    const result = await rightsContract.methods.getContentInfo(videoHash).call();
    
    console.log('内容哈希:', result.contentHash);
    console.log('注册时间:', new Date(Number(result.timestamp) * 1000));
    console.log('元数据:', JSON.parse(result.metadata));
    console.log('注册者:', result.creator);
}

// 验证视频是否被确权（通过重新计算哈希并比对）
async function verifyVideoIntegrity(filePath, expectedHash) {
    const actualHash = calculateVideoHash(filePath);
    
    if (actualHash === expectedHash) {
        console.log('✓ 视频完整性验证通过：文件未被篡改');
        return true;
    } else {
        console.log('✗ 警告：文件已被修改或不是原始版本');
        return false;
    }
}

// 确权智能合约（Solidity示例）
pragma solidity ^0.8.0;

contract ContentRegistry {
    struct ContentRecord {
        string contentHash;      // 视频内容的哈希值
        string inputData;        // 输入数据（JSON格式）
        uint256 timestamp;       // 注册时间戳
        address creator;         // 注册者地址
        string contentType;      // 内容类型
    }

    mapping(string => ContentRecord) public contentRegistry;
    mapping(address => uint256[]) public creatorRecords;

    event ContentRegistered(
        string indexed contentHash,
        address indexed creator,
        uint256 timestamp
    );

    function registerContent(
        string memory _contentHash,
        string memory _inputData,
        string memory _contentType
    ) public returns (uint256) {
        require(bytes(contentRegistry[_contentHash].contentHash).length == 0, "Content already registered");

        contentRegistry[_contentHash] = ContentRecord({
            contentHash: _contentHash,
            inputData: _inputData,
            timestamp: block.timestamp,
            creator: msg.sender,
            contentType: _contentType
        });

        creatorRecords[msg.sender].push(block.timestamp);

        emit ContentRegistered(_contentHash, msg.sender, block.timestamp);

        return block.timestamp;
    }

    function getContentInfo(string memory _contentHash) public view returns (
        string memory contentHash,
        string memory inputData,
        uint256 timestamp,
        address creator,
        string memory contentType
    ) {
        ContentRecord memory record = contentRegistry[_contentHash];
        return (
            record.contentHash,
            record.inputData,
            record.timestamp,
            record.creator,
            record.contentType
        );
    }
}