MediChain+

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/**
 * @title MediChainInsurance
 * @dev Micro-assurance paramétrique : remboursement automatique
 *      après validation du diagnostic par l'oracle médical (pont Fabric).
 */
contract MediChainInsurance is AccessControl, ReentrancyGuard {

    bytes32 public constant ORACLE_ROLE = keccak256("ORACLE_ROLE");
    bytes32 public constant INSURER_ROLE = keccak256("INSURER_ROLE");

    IERC20 public immutable stablecoin; // USDC
    uint256 public coveragePercent = 85; // 85% du montant

    struct Claim {
        address patient;
        bytes32 diagnosisHash;   // hash du DME côté Fabric
        uint256 amount;          // en USDC (6 décimales)
        uint256 timestamp;
        bool validated;
        bool paid;
    }

    mapping(bytes32 => Claim) public claims;

    event ClaimSubmitted(bytes32 indexed id, address patient, uint256 amount);
    event ClaimValidated(bytes32 indexed id);
    event ClaimPaid(bytes32 indexed id, address patient, uint256 amount);

    constructor(address _stablecoin, address oracle, address insurer) {
        stablecoin = IERC20(_stablecoin);
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(ORACLE_ROLE, oracle);
        _grantRole(INSURER_ROLE, insurer);
    }

    /// @notice Patient (ou assureur) soumet une réclamation
    function submitClaim(
        bytes32 id, address patient, bytes32 diagHash, uint256 amount
    ) external onlyRole(INSURER_ROLE) {
        require(claims[id].patient == address(0), "Claim already exists");
        claims[id] = Claim(patient, diagHash, amount, block.timestamp, false, false);
        emit ClaimSubmitted(id, patient, amount);
    }

    /// @notice L'oracle valide le diagnostic depuis le bridge Fabric
    function validateAndPay(bytes32 id, bytes32 proofHash)
        external onlyRole(ORACLE_ROLE) nonReentrant
    {
        Claim storage c = claims[id];
        require(c.patient != address(0), "Unknown claim");
        require(!c.paid, "Already paid");
        require(c.diagnosisHash == proofHash, "Hash mismatch");

        c.validated = true;
        c.paid = true;

        uint256 payout = (c.amount * coveragePercent) / 100;
        require(stablecoin.transfer(c.patient, payout), "Transfer failed");

        emit ClaimValidated(id);
        emit ClaimPaid(id, c.patient, payout);
    }
}