GameTeam

package me.monoto.towerDefense.game;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;

public class GameTeam {

    private final TeamColor      color;
    private final Set<UUID>      members    = new HashSet<>();
    private final TowerOwnership ownership  = new TowerOwnership();

    private int castleHp = 10_000;

    public GameTeam(TeamColor color) {
        this.color = color;
    }

    public void addMember(UUID player)    { members.add(player); }
    public void removeMember(UUID player) { members.remove(player); }
    public boolean hasMember(UUID player) { return members.contains(player); }
    public Set<UUID> members()            { return Collections.unmodifiableSet(members); }
    
    public TowerOwnership ownership() { return ownership; }

    /** Claim a tower on behalf of a placing player. */
    public void claimTower(UUID towerUuid, UUID playerUuid) {
        ownership.claim(towerUuid, playerUuid);
    }

    /** Release a sold/removed tower. */
    public void releaseTower(UUID towerUuid) {
        ownership.release(towerUuid);
    }

    /**
     * Can this player place, upgrade, sell, or choose a path for this tower?
     * Returns {false} if the player isn't even on this team.
     */
    public InteractResult checkInteract(UUID towerUuid, UUID playerUuid,
                                        InteractType type) {
        if (!hasMember(playerUuid)) return InteractResult.WRONG_TEAM;

        return switch (type) {
            case PLACE   -> InteractResult.ALLOWED; // validation is offloaded
            case SELL, UPGRADE_FREE ->
                    ownership.canFullyInteract(towerUuid, playerUuid)
                            ? InteractResult.ALLOWED
                            : InteractResult.NOT_OWNER;
            case UPGRADE_EXISTING_PATH ->
                    InteractResult.ALLOWED; // always allowed for teammates
            case CHOOSE_PATH ->
                    ownership.canChoosePath(towerUuid, playerUuid)
                            ? InteractResult.ALLOWED
                            : InteractResult.NOT_OWNER;
        };
    }

    public void onPlayerLeft(UUID player) {
        ownership.playerLeft(player);
    }

    public void onPlayerRejoined(UUID player) {
        ownership.playerRejoined(player);
    }
    

    public int  getCastleHp()      { return castleHp; }
    public void setCastleHp(int h) { this.castleHp = h; }
    public void damageCastle(int d){ this.castleHp = Math.max(0, castleHp - d); }
    public boolean isCastleAlive() { return castleHp > 0; }

    public TeamColor color() { return color; }
    

    public enum InteractType {
        PLACE,
        UPGRADE_EXISTING_PATH,
        UPGRADE_FREE,        // upgrade at a split point where path must be chosen
        CHOOSE_PATH,
        SELL
    }

    public enum InteractResult {
        ALLOWED,
        WRONG_TEAM,   // player is on a different team entirely
        NOT_OWNER     // player is a teammate but doesn't own it yet (grace period)
    }
}