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

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; 
import "@openzeppelin/contracts/access/AccessControl.sol";
import "../factories/ITicketContractFactory.sol";
import "../factories/ITicketTypeContractFactory.sol";
import "../interfaces/ITicketTypeContract.sol";
import "./TixSellEventLibrary.sol";  

contract EventContract  is Ownable,ReentrancyGuard,AccessControl {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    address public ticketContract; 
    address public ticketTypeContract;
     address[] public admins;
    TixSellEventLibrary.Event public theEvent;
    mapping(uint256 => uint256) public ticketTypesNbTicketMinted; //Nb of tickets minted for ticketTypes
    mapping(uint256 => uint256[]) public listOfTicketForTicketType; 
    
    // Events
    event EventCreated(string  name);
   

    constructor(
        address[] memory _admins,
        address _organizerAddress,
        address _ticketFactoryAddress,
        address _ticketTypeFactoryAddress,
        TixSellEventLibrary.Event memory _eDta,
        address _tixSellpaymentSplitter,
        address _organizerEventPaymentSplitter,
        address _resellPaiementSplitter,
        address _dataFeedEURUSD,
        address _nftTemplateAddress,
        address _ticketReservationFactoryAddress)  Ownable(_organizerAddress)  {
 
       require(_eDta.eventDate > block.timestamp, 'Event is in the past');
        
       require(_eDta.duration > 0, 'Duration >0 expected');
        
       for (uint256 i = 0; i < _admins.length; ++i) {
             _grantRole(ADMIN_ROLE, _admins[i]);
             _grantRole(DEFAULT_ADMIN_ROLE, _admins[i]);
        }
       
       admins = _admins;
       theEvent = TixSellEventLibrary.Event(
            _eDta.id,
            _eDta.eventDate,
            _eDta.duration,
            _eDta.typeEvent,
            _eDta.name,
            _eDta.description,            
            false, //Pas annulé,
            _eDta.royalty,
            _eDta.sellTixRoyaltieValue,
            _eDta.openBookings 
            );
        emit EventCreated(_eDta.name);
       
       // deploy ticket 
        ITicketContractFactory ticketContractFactory = ITicketContractFactory(_ticketFactoryAddress);
        ticketContract = ticketContractFactory.deployTicketContractForEvent(_admins, _organizerAddress, _tixSellpaymentSplitter, _organizerEventPaymentSplitter,
         _resellPaiementSplitter, _dataFeedEURUSD, address(this),_eDta.name,_nftTemplateAddress,_ticketReservationFactoryAddress,_eDta.royalty);
        // Deploy ticket Type 
      
        ITicketTypeContractFactory ticketTypeContractFactory = ITicketTypeContractFactory(_ticketTypeFactoryAddress);
        ticketTypeContract =  ticketTypeContractFactory.deployTicketTypeContractForEvent(_admins,_organizerAddress,address(this));
        
    }
 
    
    modifier onlyAdmin() {
        
         
         require(msg.sender == owner()  || msg.sender == ticketContract || hasRole(ADMIN_ROLE, msg.sender), "Only admins can do that");
        _;
    }
 
    
    function updateEvent(TixSellEventLibrary.Event memory _eDta) external onlyAdmin()  returns(bool) {

        
        if (theEvent.eventDate < block.timestamp){
           //just update metadata 
        }
        else{
            //Not started can change event date 
            require(_eDta.eventDate > block.timestamp, 'Event is in the past');
            require(_eDta.duration > 0, 'Duration >0 expected');
            theEvent.eventDate = _eDta.eventDate;
            theEvent.duration = _eDta.duration;
            theEvent.openBookings = _eDta.openBookings; 
        }
       
       //Can update only metadata
        theEvent.name = _eDta.name;
        theEvent.description = _eDta.description;
        
        theEvent.canceled = _eDta.canceled;
        return true ;
    }
    
    function createTicketType(TixSellLibrary.TicketType memory _ticketTypeData) external onlyAdmin returns (uint256 _ticketTypeId) {
        require(bytes(theEvent.id).length > 0, "Please create event first");
        uint256 ticketTypeId = 0;
       
            ticketTypeId =   ITicketTypeContract(ticketTypeContract).createTicketType(theEvent.eventDate,theEvent.openBookings,_ticketTypeData);
     
        ticketTypesNbTicketMinted[ticketTypeId] = 0 ;
        return ticketTypeId;
    }
 
 
    function bulkCreateTicketType(TixSellLibrary.TicketType[] memory _ticketsType) external  onlyAdmin {
          require(bytes(theEvent.id).length > 0, "Please create event first");
            for (uint256 i = 0; i < _ticketsType.length; i++) {
                uint256 ticketTypeId = 0;
                
                ticketTypeId = ITicketTypeContract(ticketTypeContract).createTicketType(theEvent.eventDate,theEvent.openBookings,_ticketsType[i]);
                ticketTypesNbTicketMinted[ticketTypeId] = 0 ;
               
            }
    }
 
    function getTicketTypeContract() external view returns(address){
        return ticketTypeContract;
    }
      
  
    function getTicketTypesNbMinted(uint256 _ticketTypeId) external view returns (uint256){
        return ticketTypesNbTicketMinted[_ticketTypeId];

    }

     function getListOfTicketForTicketType(uint256 _ticketTypeId) external view returns (uint256[] memory){
        return listOfTicketForTicketType[_ticketTypeId];
     }
    function addTicketToListOfTicketType(uint256 _ticketTypeId,uint256 _tokenId) external onlyAdmin {  
         listOfTicketForTicketType[_ticketTypeId].push(_tokenId);
    }

    function addTicketTypesNbTicketMinted(uint256 _ticketTypeId,uint256 amount) external onlyAdmin {
         ticketTypesNbTicketMinted[_ticketTypeId] = ticketTypesNbTicketMinted[_ticketTypeId] + amount;
    }

    function getEvent() external view returns(TixSellEventLibrary.Event memory){
        return theEvent;
    }
   
}