PAXMATA: AI-INTEGRATED BLOCKCHAIN SOLUTION FOR NON-COMMERCIAL REAL ESTATE PROJECT MANAGEMENT

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

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

contract PaxmataEscrow is ReentrancyGuard {
    using SafeERC20 for IERC20;
    
    // State variables for security
    mapping(uint256 => address) public registeredOffices;
    mapping(uint256 => address) public projectOwners;
    
    modifier onlyRegisteredOffice(uint256 projectId) {
        require(msg.sender == registeredOffices[projectId],
                "Caller is not the registered office");
        _;
    }
}

contract PaxmataNFT is ERC721URIStorage, ERC721Enumerable, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIdCounter;
    mapping(address => bool) public authorizedMinters;
    address public projectManager;
    bool private initialized;

    modifier onlyAuthorizedMinter() {
        require(authorizedMinters[msg.sender],
                "Caller is not authorized to mint");
        _;
    }
    
    function safeMint(address to, string memory metadataUrl)
        external
        onlyAuthorizedMinter
        returns (uint256) {
        require(msg.sender == projectManager,
                "Only ProjectManager can mint");
        _tokenIdCounter.increment();
        uint256 tokenId = _tokenIdCounter.current();
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, metadataUrl);
        return tokenId;
    }
}

contract OfficeContract is ReentrancyGuard {
    // Immutable state variables
    uint256 public immutable tokenId;
    address public immutable projectOwner;
    address private immutable nftContract;
    address private immutable projectManager;
    IPaxmataEscrow public immutable escrowContract;

    // Milestone structure
    struct Milestone {
        uint256 id;
        uint256 parentMilestoneId;
        uint256[] childMilestoneIds;
        uint256 payment;
        uint256 deadline;
        uint256 timestamp;
        bytes32 milestoneHash;
        bool completed;
        bool verified;
        uint8 completionPercentage;
        address recipient;
    }

    // Storage mappings
    mapping(uint256 => Milestone) public milestones;
    mapping(address => bool) public authorizedDevelopers;
    
    // Events
    event MilestoneAdded(
        uint256 indexed milestoneId,
        uint256 indexed parentId,
        address indexed recipient,
        uint256 payment,
        uint256 deadline,
        bytes32 milestoneHash
    );
}

function createOfficeAndEscrow(
    address nftContractAddress,
    address projectManagerContract,
    uint256 projectId,
    address projectOwner,
    IProjectManager.ProjectData calldata projectData,
    address paxmataWallet
) external onlyAuthorizedCreator returns (address officeAddress, address escrowAddress) {
    // Input validation
    require(nftContractAddress != address(0), "Invalid NFT contract address");
    require(projectManagerContract != address(0), "Invalid ProjectManager address");
    require(projectOwner != address(0), "Invalid project owner address");
    require(paxmataWallet != address(0), "Invalid Paxmata wallet address");
    require(officeContracts[projectId] == address(0), "Project contracts already exist");

    // Create Escrow contract
    PaxmataEscrow escrow = new PaxmataEscrow(
        projectManagerContract,
        nftContractAddress,
        paxmataWallet
    );

    escrowAddress = address(escrow);
    escrowContracts[projectId] = escrowAddress;

    emit EscrowContractCreated(projectId, escrowAddress);

    // Create Office contract
    OfficeContract office = new OfficeContract(
        nftContractAddress,
        projectManagerContract,
        projectId,
        projectOwner,
        escrowAddress,
        projectData
    );

    officeAddress = address(office);
    officeContracts[projectId] = officeAddress;

    emit OfficeContractCreated(projectId, officeAddress);

    return (officeAddress, escrowAddress);
}