package resources;

import java.util.Comparator;
import java.util.List;
import java.util.Map;

import static views.Constants.DECK_COUNT;
import static views.Constants.HAND_COUNT;

public class Algo {
    private LoseB loseB;
    private HandsB handsB;
    private LoseA loseA;
    private HandsA handsA;
    private Deck deck;
    private ResultByDrawingA resultByDrawingA;
    private ResultByDrawingB resultByDrawingB;
    private ResultBySelectingA resultBySelectingA;
    private ResultBySelectingB resultBySelectingB;
    int turnCount = 0;
    boolean isATurn;

    public Algo() {
        ///モデル生成分
        loseB = new LoseB();
        handsB = new HandsB(loseB);
        loseA = new LoseA();
        handsA = new HandsA(loseA);
        deck = new Deck();
        resultByDrawingA = new ResultByDrawingA(handsB, deck, handsA);
        resultByDrawingB = new ResultByDrawingB(deck, handsB, handsA);
        resultBySelectingA = new ResultBySelectingA(handsB, handsA);
        resultBySelectingB = new ResultBySelectingB(handsA, handsB);
        //追加分
        isATurn = true;
        deck.init(DECK_COUNT);

    }

    public void drawAndAttackA(int target, int guess) {
        this.resultByDrawingA.drawAndAttackA(target, guess);
    }

    public void selectAndAttackA(int attacker, int target, int guess) {
        this.resultBySelectingA.selectAndAttackA(attacker, target, guess);
    }

    public void drawAndAttackB(int target, int guess) {
        this.resultByDrawingB.drawAndAttackB(target, guess);
    }

    public void selectAndAttackB(int attacker, int target, int guess) {
        this.resultBySelectingB.selectAndAttackB(attacker, target, guess);
    }

    public Map.Entry<Boolean, Integer> getResultByDrawingA() {
        return resultByDrawingA.getValue();
    }

    public Map.Entry<Boolean, Integer> getResultByDrawingB() {
        return resultByDrawingB.getValue();
    }

    public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getResultBySelectingA() {
        return resultBySelectingA.getValue();
    }

    public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getResultBySelectingB() {
        return resultBySelectingB.getValue();
    }

    public List<Map.Entry<Integer, Boolean>> getDeck() {
        return deck.getValue();
    }

    public boolean getLoseA() {
        return loseA.getValue();
    }

    public boolean getLoseB() {
        return loseB.getValue();
    }

    public List<Map.Entry<Integer, Boolean>> getHandsA() {
        return handsA.getValue();
    }

    public List<Map.Entry<Integer, Boolean>> getHandsB() {
        return handsB.getValue();
    }



    //追加分
    /**
     * 各プレイヤーに手札を配るメソッド
     */
    public void distributeHands(){
        for (int i = 0; i < HAND_COUNT; i++) {
            handsA.getValue().add(deck.head());
            handsB.getValue().add(deck.head());
        }
        getHandsA().sort(Comparator.comparing(Map.Entry<Integer, Boolean>::getKey));
        getHandsB().sort(Comparator.comparing(Map.Entry<Integer, Boolean>::getKey));
    }
    public void setDeck(int... param){
        deck.setValue(param);
    }
    public boolean isATurn() {
        return isATurn;
    }

    public void updateTurn() {
        isATurn = !isATurn;
    }
}