const PHASE_REINFORCE = 1;
const PHASE_ATTACK = 2;
const PHASE_FORTIFY = 3;

let totalDice = 0;

class Player {
    constructor(id, name) {
        this.name = name;
        this.timeout = null;
        this.id = id;
        this.ready = false;

        // Data which is reset every turn
        this.isPlaying = false;
        this.reinforcementsPlaced = 0;
        this.reinforcementsAvailable = 0;
        this.offenderRegion = null;
        this.turnPhase = PHASE_REINFORCE;

        // Data for defending
        this.defenderPromise = null;
        this.defenderAmount = null;

        this.resetColor();
    }

    resetTimeout() {
        if (this.timeout !== null) {
            window.clearTimeout(this.timeout);
        }

        this.timeout = window.setTimeout(() => {
            if (players[this.id] !== undefined) {
                delete players[this.id];
            }
            updateDom();
        }, TIMEOUT);
    }

    /**
     * Get our color as used on the board.
     */
    getColor() {
        return this.color;
    }

    resetColor() {
        let randomColor = Math.random() * 360;
        this.color = `hsl(${randomColor} 57% 50%)`;
    }

    /**
     * Claim a region of the map.
     *
     * @param data Data received via socket.
     */
    claim(data) {
        let region = Region.getRegion(data.region);

        if (region.owner === null) {
            region.claim(this);
            return true;
        } else {
            return false;
        }
    }

    /**
     * Reinforce a region of the map.
     *
     * @param data Data received via socket.
     */
    reinforce(data) {
        let region = Region.getRegion(data.region);

        if (region.owner === this) {
            region.reinforce(1);
            return true;
        } else {
            return false;
        }
    }

    /**
     * Process a generic action packet representing a player's move.
     *
     * @param data Data received via socket
     * @returns {boolean} Whether this player's turn has ended or not.
     */
    async act(data) {
        console.log(`player: ${this.id}`);
        console.log(data);

        if (this.turnPhase === PHASE_REINFORCE) {
            if (data.region !== undefined) {
                if (this.reinforce(data)) {
                    this.reinforcementsPlaced += 1;
                }

                if (this.reinforcementsPlaced === this.reinforcementsAvailable) {
                    this.turnPhase = PHASE_ATTACK;
                }
            }

            return false;
        } else {
            // End turn prematurely.
            if (data.action === "END") {
                return true;
            }

            if (this.turnPhase === PHASE_ATTACK && data.action === "ATTACK") {
                await this.attack(data);
                return false;
            }

            this.turnPhase = PHASE_FORTIFY;

            if (data.action === "FORTIFY") {
                return this.fortify(data);
            }
        }
        return false;
    }

    /**
     * Process an action which is to attack another region.
     *
     * @param data Data received via socket
     */
    async attack(data) {
        let offender = Region.getRegion(data.startRegion);
        let defender = Region.getRegion(data.endRegion);
        let offenderStrength = parseInt(data.strength);

        // Basic validation on game state
        if (
            offender.owner !== this ||
            defender.owner === this ||
            offenderStrength > 3 ||
            offenderStrength <= 0 ||
            offenderStrength >= offender.strength ||
            (this.offenderRegion !== null && this.offenderRegion !== offender)
        ) {
            return false;
        }

        // If we're the defender, we need to send a packet to state our defense.
        if (defender.owner === us) {
            showDefenseDom();
        }

        // Grab the defense amount from
        let defenderStrength = 0;
        while (
            defenderStrength <= 0 ||
            defenderStrength > Math.min(2, defender.strength)
        ) {
            defenderStrength = await defender.owner.getDefense();
        }

        /* How do Risk attacks work?
        - Offender signs 1-3 armies, defender signs 1-2 armies
        - Both roll respective dice
        - Compare pairs of highest die in the rolls to remove armies.
         */

        if (this.offenderRegion === null) {
            this.offenderRegion = offender;
        }

        let offenderRolls = [];
        let defenderRolls = [];

        // Get random values
        for (let i = 0; i < offenderStrength; i++) {
            offenderRolls.push(await random.get(6, `dice-${totalDice}`));
            totalDice += 1;
        }

        for (let i = 0; i < defenderStrength; i++) {
            defenderRolls.push(await random.get(6, `dice-${totalDice}`));
            totalDice += 1;
        }

        console.log(`attacker rolls: ${offenderRolls}`);
        console.log(`defender rolls: ${defenderRolls}`);

        offenderRolls.sort();
        defenderRolls.sort();

        // Compare and settle.
        while (offenderRolls.length * defenderRolls.length > 0) {
            let offenderResult = offenderRolls.pop();
            let defenderResult = defenderRolls.pop();

            if (offenderResult > defenderResult) {
                defender.strength -= 1;
            } else {
                offender.strength -= 1;
            }

            if (defender.strength === 0) {
                defender.strength = offenderRolls.length + 1;
                offender.strength -= offenderRolls.length + 1;
                defender.owner = this;
                break;
            }
        }

        // Reset the promises in case they attack again.
        defender.owner.defenderPromise = null;
        defender.owner.defenderAmount = null;

        updateDom();
    }

    async setDefense(amount) {
        await navigator.locks.request("defender", () => {
            this.defenderAmount = amount;
            if (this.defenderPromise !== null) {
                this.defenderPromise(amount);
            }
        });
    }

    async getDefense() {
        let promise, resolver;
        await navigator.locks.request("defender", () => {
            if (this.defenderAmount === null) {
                promise = new Promise((resolve) => {
                    resolver = resolve;
                });
                this.defenderPromise = resolver;
            } else {
                promise = new Promise((resolve) => {
                    resolve(this.defenderAmount);
                });
            }
        });
        return promise;
    }

    /**
     * Process an action which is to attack another region.
     *
     * @param data Data received via socket
     */
    fortify(data) {
        let sender = Region.getRegion(data.startRegion);
        let receiver = Region.getRegion(data.endRegion);
        let strength = parseInt(data.strength);

        if (
            sender.owner === this &&
            receiver.owner === this &&
            sender.strength > strength &&
            strength > 0
        ) {
            receiver.reinforce(strength);
            sender.strength -= strength;
            return true;
        } else {
            return false;
        }
    }

    /**
     * Calculate the number of additional reinforcements to gain on this turn.
     */
    additionalReinforcements() {
        return Math.min(
            3,
            Math.floor(
                Object.values(REGIONS).filter((region) => region.owner === this).length /
                    3
            )
        );
    }

    /**
     * Start a player's turn.
     */
    startTurn() {
        this.isPlaying = true;
        this.reinforcementsPlaced = 0;
        this.reinforcementsAvailable = this.additionalReinforcements();
        this.offenderRegion = null;
        this.turnPhase = PHASE_REINFORCE;
    }

    /**
     * End player's turn
     */
    endTurn() {
        this.isPlaying = false;
        this.nextPlayer().startTurn();
    }

    nextPlayer() {
        let sorted = Object.values(players).sort((a, b) => (a.id < b.id ? -1 : 1));
        let ourIndex = sorted.findIndex((player) => player.id === this.id);

        return sorted[(ourIndex + 1) % sorted.length];
    }
}