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


import "@openzeppelin/contracts/access/Ownable.sol"; 
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./factories/IEventContractFactory.sol";
import "./factories/IContentContractFactory.sol";

import "./OrganizerEventPaymentSplitter.sol"; 
import "./ResellablePaymentSplitter.sol";  
//import "hardhat/console.sol";
contract OrganizerContract  is Ownable,AccessControl {
   bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    address[] public admins;
   address organizerAddress;
   address payable  tixSellpaymentSplitter;
   //address payable public resellPaiementSplitter;
   address[] public deployedEventContract;
   address[] public deployedContentContract;
   address nftTemplateAddress;
   // get payment splitter address for specific eventCoontractAddress
   mapping(address => address payable) public organizerEventPaymentSplitter;
   mapping(address => address payable) public organizerResellEventPaymentSplitter;
   mapping(address => address payable) public organizerContentPaymentSplitter;
   mapping(address => address payable) public organizerResellContentPaymentSplitter;
   address public orgaPaymentContentSplitterContrat; 
   
   address  addressChainLinkConverter = TixSellLibrary.addressChainLinkConverter  ;
   IEventContractFactory private eventContractFactory;
   IContentContractFactory private contentContractFactory;
   address ticketContractFactoryAddress;
   address ticketTypeFactoryAddress;
   address ticketReservationFactoryAddress;
   address contentTicketContractFactoryAddress; 
    constructor(address[] memory _admins, address _organizerAddress, address _tixSellPaymentSplitter,
    address _eventContractFactory, address _ticketContractFactory,address _ticketTypeFactoryAddress,address _nftTemplateAddress,address _ticketReservationFactoryAddress,
    address _contentContractFactory,address _contentTicketFactory)   Ownable(_organizerAddress)  {
        tixSellpaymentSplitter = payable(_tixSellPaymentSplitter);
        organizerAddress = _organizerAddress;
       // resellPaiementSplitter = payable(_resellPaiementSplitter);
        // Factories 
        eventContractFactory = IEventContractFactory(_eventContractFactory);
        contentContractFactory = IContentContractFactory(_contentContractFactory);
        ticketContractFactoryAddress = _ticketContractFactory;
        ticketTypeFactoryAddress = _ticketTypeFactoryAddress;
       
        contentTicketContractFactoryAddress = _contentTicketFactory;
        nftTemplateAddress = _nftTemplateAddress;
        ticketReservationFactoryAddress = _ticketReservationFactoryAddress;
        admins = _admins;  
         
        for (uint256 i = 0; i < _admins.length; ++i) {
            
            _grantRole(ADMIN_ROLE, _admins[i]);
            _grantRole(DEFAULT_ADMIN_ROLE, _admins[i]);
        }
        address[] memory payees = new address[](1);
        payees[0]=address(_organizerAddress);
        uint256[] memory shares = new uint256[](1);
        shares[0]=100;
        OrganizerEventPaymentSplitter theOrganizerEventPaymentSplitterContract = new OrganizerEventPaymentSplitter(payees,shares);
        orgaPaymentContentSplitterContrat = payable(address(theOrganizerEventPaymentSplitterContract));
        
    }
  
   modifier onlyAdmin() {
         require(msg.sender == owner() || hasRole(ADMIN_ROLE, msg.sender), "DOES_NOT_HAVE_ADMIN_ROLE");
        _;
    }
   

    //Be able to update _eventContractFactory _ticketContractFactory _ticketTypeFactoryAddress _nftTemplateAddress _ticketReservationFactoryAddress _tixSellPaymentSplitter addressChainLinkConverter
    function updateFactories( address _tixSellPaymentSplitter, address _addressChainLinkConverter,
    address _eventFactoryAddress,address _contentFactoryAddress,address _ticketFactoryAddress,
    address _ticketTypeFactoryAddress,address _nftTemplateAddress,address _ticketReservationFactoryAddress, address _contentTicketFactory) external onlyAdmin {
        tixSellpaymentSplitter = payable(_tixSellPaymentSplitter);
        addressChainLinkConverter = _addressChainLinkConverter;
        eventContractFactory = IEventContractFactory(_eventFactoryAddress);
        contentContractFactory = IContentContractFactory(_contentFactoryAddress);
        ticketContractFactoryAddress = _ticketFactoryAddress;
        ticketTypeFactoryAddress = _ticketTypeFactoryAddress;
        nftTemplateAddress = _nftTemplateAddress;
        ticketReservationFactoryAddress = _ticketReservationFactoryAddress;
        contentTicketContractFactoryAddress = _contentTicketFactory;
    }
   function deployNewEventTicketContract(TixSellEventLibrary.Event memory _eventData,address[] memory payees,uint256[] memory shares_) external onlyAdmin returns(address) {
        // Contract belongs to our factory... 
         // deploy paymentsplitter 
        
            OrganizerEventPaymentSplitter theOrganizerEventPaymentSplitterContract = new OrganizerEventPaymentSplitter(payees,shares_);
            address paymentEventSplitterContrat = payable(address(theOrganizerEventPaymentSplitterContract));
        
        // //Resell payment splitters with TixSell
        //Resell payment splitter envoi X % sur organizerPaymentContract et % sur Tixsell contrat
        address[] memory resellpayees = new address[](2);
        resellpayees[0]=address(paymentEventSplitterContrat);
        resellpayees[1]= address(tixSellpaymentSplitter);
        
        uint96 sellTixRoyalty = _eventData.sellTixRoyaltieValue / 100;
        uint96 amountToSubstract = 100 - sellTixRoyalty;
        uint256[] memory resellshares = new uint256[](2);
        resellshares[0]=amountToSubstract;
        resellshares[1]=sellTixRoyalty;
        
        ResellablePaymentSplitter theResellPaymentSplitterContract = new ResellablePaymentSplitter(admins,resellpayees,resellshares);
        address resellPaiementSplitter = payable(address(theResellPaymentSplitterContract));
         

        address _eventContract = eventContractFactory.deployEventContract(admins, organizerAddress,ticketContractFactoryAddress,ticketTypeFactoryAddress,_eventData, tixSellpaymentSplitter, paymentEventSplitterContrat, resellPaiementSplitter, addressChainLinkConverter,nftTemplateAddress,ticketReservationFactoryAddress);
        deployedEventContract.push(_eventContract); 
        
       
        organizerEventPaymentSplitter[_eventContract] = payable(paymentEventSplitterContrat);
        organizerResellEventPaymentSplitter[_eventContract] = payable(resellPaiementSplitter);
       
        return (_eventContract);
    }

    // deployContentContract & init _organizerContentPaymentSplitter
    function deployNewContentTicketContract(TixSellContentLibrary.Content memory _contentData) external onlyAdmin returns(address) {
        // Contract belongs to our factory... 
         // deploy paymentsplitter 
         // //Resell payment splitters with TixSell
        //Resell payment splitter envoi X % sur organizerPaymentContract et % sur Tixsell contrat
        address[] memory resellpayees = new address[](2);
        resellpayees[0]=address(orgaPaymentContentSplitterContrat);
        resellpayees[1]= address(tixSellpaymentSplitter);
        
        uint96 sellTixRoyalty = _contentData.sellTixRoyaltieValue / 100;
        uint96 amountToSubstract = 100 - sellTixRoyalty;
        uint256[] memory resellshares = new uint256[](2);
        resellshares[0]=amountToSubstract;
        resellshares[1]=sellTixRoyalty;
        
        ResellablePaymentSplitter theResellPaymentSplitterContract = new ResellablePaymentSplitter(admins,resellpayees,resellshares);
        address resellPaiementSplitter = payable(address(theResellPaymentSplitterContract));
      
         
        address _contentContract = contentContractFactory.deployContentContract(admins, organizerAddress,contentTicketContractFactoryAddress,_contentData, tixSellpaymentSplitter, orgaPaymentContentSplitterContrat, resellPaiementSplitter, addressChainLinkConverter);
        deployedContentContract.push(_contentContract); 
        organizerResellContentPaymentSplitter[_contentContract] = payable(resellPaiementSplitter);
        
       return (_contentContract);
    }

    function fetchEventsContract()
        public
        view
        returns (address[] memory)
    {
        uint256 totalItemCount = deployedEventContract.length;
        address[] memory items = new address[](totalItemCount);
        for (uint256 i = 0; i < totalItemCount; i++) {
            items[i] =  deployedEventContract[i];
        }
        return items;
    }

     function fetchContentContract()
        public
        view
        returns (address[] memory)
    {
        uint256 totalItemCount = deployedContentContract.length;
        address[] memory items = new address[](totalItemCount);
        for (uint256 i = 0; i < totalItemCount; i++) {
            items[i] =  deployedContentContract[i];
        }
        return items;
    }
}