pragma solidity ^0.4.17;

import "./Session.sol";
contract Main {
    struct Participant {
        uint participantId;
        string fullname;
        string email;
        uint deviation;
        uint numberPricing;
        address _account;
        bool accesslogin;
        bool loginBefore;
    }
    
    uint participantCount = 0;
    uint maxParticipant = 10;
     
    address public admin;
    Session public session;
    mapping(address => Participant) public participants;
    
    function Main() public {
        admin = msg.sender;
        session = new Session();
    }
    
    function register() public {
        if(participantCount > maxParticipant - 1) {
            revert();
        }
        
        Participant storage currentParticipant = participants[msg.sender];
        currentParticipant.participantId = participantCount;
        currentParticipant._account = msg.sender;
        currentParticipant.deviation = 0;
        currentParticipant.numberPricing = 0;
        currentParticipant.loginBefore = false;
        currentParticipant.accesslogin = false;
    }
    
    function updateInfor(string fullname, string email) public {
        Participant storage currentParticipant = participants[msg.sender];
        currentParticipant.fullname = fullname;
        currentParticipant.email = email;
        currentParticipant.loginBefore = true;
        currentParticipant.accesslogin = true;
    }
    
    function startSession(uint _productId) public validRequire(true, false) {
        session.startSession(_productId);
    }
    
    
    function addNewProduct(string name, string description) public validRequire(true, false) {
        session.addNewProduct(name, description);
    }
    
    function updateProduct(uint productId, string name, string description) public validRequire(true, false) {
        session.updateProduct(productId, name, description);
    }
    
    function priceProduct(uint _productId, uint _price) public validRequire(false, true) {
        bool checkParticipantPicing = session.checkParticipantPicing(_productId, msg.sender);
        if(!checkParticipantPicing) {
            participants[msg.sender].numberPricing = participants[msg.sender].numberPricing + 1;
        }
        session.pricing(_productId, _price, msg.sender);
        calculatorProposedPrice(_productId);
        
    }
    
    function closeSession(uint _productId, uint finalPrice) public {
        uint dnew = session.closeSession(_productId, finalPrice);
        
        uint numberProductTokens = session.numberProductToken(_productId);
        for(uint productTokenId = 0; productTokenId < numberProductTokens; productTokenId ++) {
            var (account, price) = session.viewPricingSession(_productId, productTokenId);
            uint dcurrent = participants[account].deviation;
            uint n = participants[account].numberPricing;
            uint d = (dcurrent*n + dnew)/(n + 1);
            participants[account].deviation = d;
            
        }
    }
    
    function getNumberPricingSession() public view returns(uint){
        uint data;
        data = session.numberPricingSession();
        return data;
    }
    
    function viewProduct(uint productId) public returns(uint, uint, uint) {
        return (session.viewProduct(productId));
    }
    
    function numberProductToken(uint productId) public returns(uint) {
        return (session.numberProductToken(productId));
    }
    
    function viewPricingSession(uint productId, uint productTokenNumber) public returns( address, uint) {
        return (session.viewPricingSession(productId, productTokenNumber));
    }
    
    function calculatorProposedPrice(uint productId) public {
        uint numberProductTokens = session.numberProductToken(productId);
        uint totalPrice = 0;
        uint totalDeviation = 0;
        for(uint productTokenId = 0; productTokenId < numberProductTokens; productTokenId ++) {
            var (account, price) = session.viewPricingSession(productId, productTokenId);
            totalPrice += price*(100 - participants[account].deviation);
            totalDeviation += participants[account].deviation;
            
        }
        uint result = totalPrice/(100*numberProductTokens - totalDeviation);
        session.setProposedPrice(productId, result);
        
    }
    
     modifier validRequire(bool requireAdmin, bool requireLogin)
    { 
        if(requireAdmin) {
            require(msg.sender == admin);
        }
        
        if(requireLogin) {
            Participant storage currentParticipant = participants[msg.sender];
            require(currentParticipant.accesslogin);
        }
        _;
    }
}