Untitled

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

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

contract PropertyListing is ERC1155, Ownable {

    struct Fraction {
        uint256 fractionId;
        address receiver;
        uint256 amount;
    }

    struct Property {
       uint256 tokenId;
       uint256 metadataURL; 
    }

    mapping(uint256 => Fraction[]) fractions;
    mapping(uint256 => Property) public properties;

    constructor(address initialOwner, string memory uri)
        Ownable(initialOwner)
        ERC1155(uri) {
    }

    event PropertyListed(uint256 id);

    function createProperty(
        uint256 tokenId,
        Property calldata params
    ) external onlyOwner returns (uint256) {
        properties[tokenId] = params;
        emit PropertyListed(tokenId);
        return tokenId;
    }

    function getProperty(uint256 tokenId)
        public 
        view 
        returns (
            Property memory
        ) {
        return properties[tokenId];
    }

    function createFraction(
        uint256 tokenId, Fraction calldata fraction
    ) external onlyOwner returns (uint256) {

        Fraction[] memory fractionList = fractions[tokenId];
        for (uint256 i = 0; i < fractionList.length; i++) {
            if (fractionList[i].fractionId == fraction.fractionId) {
                fractions[tokenId][i] = fraction;
                return tokenId;
            }
        }
        revert("tokenId not found");

    }

    function getFraction(uint256 tokenId, Fraction calldata fraction)
        public
        view
        returns (
            Fraction memory
        ) {

        Fraction[] memory fractionList = fractions[tokenId];
        for (uint256 i = 0; i < fractionList.length; i++) {
            if (fractionList[i].fractionId == fraction.fractionId) {
                return fractions[tokenId][i];
            }
        }
        revert("tokenId not found");

    }

    function mintProperty(uint256 tokenId) public {

        Fraction[] memory frac = fractions[tokenId];
        for (uint256 idx = 0; idx < frac.length; idx++) {
            uint256 count = 0;
            uint256[] memory amounts;
            uint256[] memory tokenList;

            for (uint256 i = 0; i < frac.length; i++) {
                if (frac[i].receiver == frac[0].receiver) {
                    tokenList[count] = tokenId;
                    amounts[count] = frac[i].amount;
                    count++;
                } 
            }
            _mintBatch(frac[idx].receiver, tokenList, amounts, "");
            count = 0;
        }

    }

    function burnProperty(uint256 tokenId) public onlyOwner {
        Fraction[] memory frac = fractions[tokenId];

        for (uint256 idx = 0; idx < frac.length; idx++) {
                uint256 count = 0;
                uint256[] memory amounts;
                uint256[] memory tokenList;
                for (uint256 i = 0; i < frac.length; i++) {
                    if (frac[i].receiver == frac[0].receiver) {
                        tokenList[count] = tokenId;
                        amounts[count] = frac[i].amount;
                        count++;
                    } 
                }
                _burnBatch(frac[idx].receiver, tokenList, amounts);
                count = 0;
            }
        }

}