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

import "@openzeppelin/contracts/access/Ownable.sol"; 
import "@openzeppelin/contracts/access/AccessControl.sol";
import "../TixSellLibraries.sol";  
contract TicketTypeContract is Ownable, AccessControl {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
       address[] public admins;
    uint256 private _nextTicketTypeId;
    address private organizer; 
    // Mappings
    mapping(uint256 => TixSellLibrary.TicketType) public ticketTypes;
    

    event TicketTypeCreated(uint256 ticketTypeId);
     event TicketTypeDeleted(uint256 ticketTypeId);

    //1 smart contract par organisateur
    modifier onlyFounders() {
        require(hasRole(ADMIN_ROLE, msg.sender), "Only founders can do that");
        _;
    }

    modifier onlyAdmin() {
        
        require(
            msg.sender == owner()  || msg.sender == organizer  || hasRole(ADMIN_ROLE, msg.sender),
            "Only admins can do that"
        );
        _;
    }

    constructor(address initialOwner,address[] memory _admins,address _organizerAddress)  Ownable(initialOwner)  {
        for (uint256 i = 0; i < _admins.length; ++i) {
            _grantRole(ADMIN_ROLE, _admins[i]);
            _grantRole(DEFAULT_ADMIN_ROLE, _admins[i]);
        }
        admins = _admins;
        organizer = _organizerAddress;
    }


      modifier checkParameters( uint256 _eventDate,bool _openBookings,TixSellLibrary.TicketType memory _ticketTypeData) {

        // check dates
        require(
            _ticketTypeData.templateId > 0,
            "Please set ticketType templateId"
        );
        
        require(
            _ticketTypeData.maxTickets > 0,
            "MaxTickets should be greater than 0"
        );
        require(
            _ticketTypeData.maxTicketsPerUser <= _ticketTypeData.maxTickets,
            "_maxTicketsPerUser should be less than maxTickets"
        );
        require(
            _ticketTypeData.maxTicketsPerUser > 0,
            "MaxTicketsPerUser should be more than 0"
        );
        
        if (!_openBookings){
            require(
                        _ticketTypeData.bookingEndDate <= _eventDate,
                        "booking end date should be before event date"
                    );
        }
       
        require(
            _ticketTypeData.bookingEndDate > _ticketTypeData.bookingStartDate,
            "booking end date should be after start date"
        );
        if (!_ticketTypeData.revealed) {
            require(
                _ticketTypeData.revealStartDate >
                    _ticketTypeData.bookingStartDate,
                "Revealed date should be after booking start date"
            );
            if (!_openBookings){
                require(
                    _ticketTypeData.revealStartDate <= _eventDate,
                    "reveal start date should be before event date"
                );
             }
            require(
                bytes(_ticketTypeData.hiddenuri).length > 0,
                "Hidden uri missing"
            );
        }
 
        if (_ticketTypeData.earlyBid) {
            require(
                _ticketTypeData.discountEndDate <
                    _ticketTypeData.bookingEndDate,
                "Discount end date should be before booking end date"
            );
            require(
                _ticketTypeData.discountPrice > 0,
                "Discount price should be greater than 0"
            );
            require(
                _ticketTypeData.discountPrice < _ticketTypeData.ticketPrice,
                "Discount price should be less than ticketPrice"
            );
        }

        _;
    }


    function createTicketType(uint256 _eventDate,bool _openBookings,TixSellLibrary.TicketType memory _ticketTypeData) external checkParameters(_eventDate,_openBookings,_ticketTypeData) onlyAdmin returns (uint256 _ticketTypeId)
    {
        //Create ticket types
        uint256 ticketTypeId = _nextTicketTypeId;

        ticketTypes[ticketTypeId] = TixSellLibrary.TicketType(
            ticketTypeId,
            _ticketTypeData.maxTickets,
            _ticketTypeData.maxTicketsPerUser,
            _ticketTypeData.ticketPrice,
            _ticketTypeData.bookingStartDate,
            _ticketTypeData.bookingEndDate,
            _ticketTypeData.revealed,
            _ticketTypeData.revealStartDate,
            _ticketTypeData.sellable,
            _ticketTypeData.maxSellablePrice,
            _ticketTypeData.royaltySellable,
            _ticketTypeData.earlyBid,
            _ticketTypeData.discountPrice,
            _ticketTypeData.discountEndDate,
            _ticketTypeData.templateId,
            _ticketTypeData.fixAmount,
            _ticketTypeData.freeDrink,
            _ticketTypeData.priorityQueue,
             _ticketTypeData.canStream,
            _ticketTypeData.name,
            _ticketTypeData.hiddenuri,
            _ticketTypeData.image,
            _ticketTypeData.ticketDesignInfo
        );
       
        _nextTicketTypeId+=1;
         emit TicketTypeCreated(ticketTypeId);
        return ticketTypeId;
    }
 
    function changeFixAmountForTicketType(uint _ticketTypeId,uint256 _newAmount) external onlyFounders returns (bool){
         TixSellLibrary.TicketType storage theTicketType = ticketTypes[
            _ticketTypeId
        ];
        require(theTicketType.maxTickets > 0, "TicketType doesn't exists");
        theTicketType.fixAmount = _newAmount;
        return true;
    }
    function deleteTicketType(uint256 _ticketTypeId) external  onlyAdmin   {
        
         TixSellLibrary.TicketType storage theTicketType = ticketTypes[
            _ticketTypeId
        ];
        require(theTicketType.maxTickets > 0, "TicketType doesn't exists");
        delete ticketTypes[_ticketTypeId];
         emit TicketTypeDeleted(_ticketTypeId);
    }
 
     function getTicketTypeInfo(uint256 _ticketTypeId) external view returns (TixSellLibrary.TicketType memory){
        return  ticketTypes[_ticketTypeId];
     }

    

      function fetchTicketsType()
        public
        view
        returns (TixSellLibrary.TicketType[] memory)
    {
        uint256 totalItemCount = _nextTicketTypeId;
        uint256 itemCount = 0 ;
        for (uint256 i = 0; i <totalItemCount; i++) {
         
            if ( ticketTypes[i].maxTickets>0) {
                itemCount += 1;
            }
        }
        TixSellLibrary.TicketType[] memory items = new TixSellLibrary.TicketType[](itemCount);
        uint256 boucle=0;
        //Return only not deleted ticketTypes
        for (uint256 i = 0; i < totalItemCount; i++) {
            //TixSellLibrary.TicketType memory aTicketType = ticketTypes[i];
            if (ticketTypes[i].maxTickets>0){
                items[boucle] = ticketTypes[i];
                boucle+=1;
            }
        }
        return items;
    }
}