// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

part of hearts;

class HeartsCommand extends GameCommand {
  // Usually this constructor is used when reading from a log/syncbase.
  HeartsCommand(String phase, String data)
      : super(phase, data, simultaneity: computeSimul(phase));

  HeartsCommand.fromCommand(String cmd)
      : super(cmd.split("|")[0], cmd.split("|")[1],
            simultaneity: computeSimul(cmd.split("|")[0]));

  // The following constructors are used for the player generating the HeartsCommand.
  HeartsCommand.deal(int playerId, List<Card> cards)
      : super("Deal", computeDeal(playerId, cards),
            simultaneity: SimulLevel.independent);

  HeartsCommand.pass(int senderId, List<Card> cards)
      : super("Pass", computePass(senderId, cards),
            simultaneity: SimulLevel.independent);

  HeartsCommand.take(int takerId)
      : super("Take", computeTake(takerId),
            simultaneity: SimulLevel.independent);

  HeartsCommand.play(int playerId, Card c)
      : super("Play", computePlay(playerId, c),
            simultaneity: SimulLevel.turnBased);

  HeartsCommand.ask()
      : super("Ask", computeAsk(), simultaneity: SimulLevel.turnBased);

  HeartsCommand.takeTrick()
      : super("TakeTrick", computeTakeTrick(),
            simultaneity: SimulLevel.turnBased);

  HeartsCommand.ready(int playerId)
      : super("Ready", computeReady(playerId),
            simultaneity: SimulLevel.independent);

  static SimulLevel computeSimul(String phase) {
    switch (phase) {
      case "Deal":
        return SimulLevel.independent;
      case "Pass":
        return SimulLevel.independent;
      case "Take":
        return SimulLevel.independent;
      case "Play":
        return SimulLevel.turnBased;
      case "Ask":
        return SimulLevel.turnBased;
      case "TakeTrick":
        return SimulLevel.turnBased;
      case "Ready":
        return SimulLevel.independent;
      default:
        print(phase);
        assert(false); // How could this have happened?
        return null;
    }
  }

  static String computeDeal(int playerId, List<Card> cards) {
    StringBuffer buff = new StringBuffer();
    buff.write("$playerId:");
    cards.forEach((card) => buff.write("${card.toString()}:"));
    buff.write("END");
    return buff.toString();
  }

  static String computePass(int senderId, List<Card> cards) {
    StringBuffer buff = new StringBuffer();
    buff.write("$senderId:");
    cards.forEach((card) => buff.write("${card.toString()}:"));
    buff.write("END");
    return buff.toString();
  }

  static String computeTake(int takerId) {
    return "$takerId:END";
  }

  static String computePlay(int playerId, Card c) {
    return "$playerId:${c.toString()}:END";
  }

  static String computeAsk() {
    return "END";
  }

  static String computeTakeTrick() {
    return "END";
  }

  static String computeReady(int playerId) {
    return "$playerId:END";
  }

  @override
  bool canExecute(Game g) {
    // TODO(alexfandrianto): This is very similar to execute, but without the
    // mutations. It's possible to use a shared function to simplify/combine the
    // logic.
    HeartsGame game = g as HeartsGame;

    print("HeartsCommand is checking: $data");
    List<String> parts = data.split(":");
    switch (phase) {
      case "Deal":
        if (game.phase != HeartsPhase.deal) {
          return false;
        }
        // Deal appends cards to playerId's hand.
        int playerId = int.parse(parts[0]);
        List<Card> hand = game.cardCollections[playerId];
        if (hand.length + parts.length - 3 > 13) {
          return false;
        }

        // The last part is 'END', but the rest are cards.
        for (int i = 1; i < parts.length - 1; i++) {
          Card c = new Card.fromString(parts[i]);
          bool canTransfer = this.transferCheck(game.deck, hand, c);
          if (!canTransfer) {
            return false;
          }
        }
        return true;
      case "Pass":
        if (game.phase != HeartsPhase.pass) {
          return false;
        }
        // Pass moves a set of cards from senderId to receiverId.
        int senderId = int.parse(parts[0]);
        int receiverId = senderId + HeartsGame.offsetPass;
        List<Card> handS = game.cardCollections[senderId];
        List<Card> handR = game.cardCollections[receiverId];

        int numPassing = parts.length - 2; // not senderId and not end
        if (numPassing != 3) {
          return false;
        }

        // The last part is 'END', but the rest are cards.
        for (int i = 1; i < parts.length - 1; i++) {
          Card c = new Card.fromString(parts[i]);
          bool canTransfer = this.transferCheck(handS, handR, c);
          if (!canTransfer) {
            return false;
          }
        }
        return true;
      case "Take":
        if (game.phase != HeartsPhase.take) {
          return false;
        }
        return true;
      case "Play":
        if (game.phase != HeartsPhase.play) {
          return false;
        }

        // Can play if the game is asking for a card to be played.
        if (!game.asking) {
          return false;
        }

        // Play the card from the player's hand to their play pile.
        int playerId = int.parse(parts[0]);
        int targetId = playerId + HeartsGame.offsetPlay;
        List<Card> hand = game.cardCollections[playerId];
        List<Card> discard = game.cardCollections[targetId];

        Card c = new Card.fromString(parts[1]);

        // If the card isn't valid, then we have an error.
        String reason = game.canPlay(playerId, c);
        if (reason != null) {
          return false;
        }
        bool canTransfer = this.transferCheck(hand, discard, c);
        return canTransfer;
      case "Ask":
        if (game.phase != HeartsPhase.play) {
          return false;
        }
        if (game.allPlayed) {
          return false;
        }
        return !game.asking; // Can ask if you're not asking.
      case "TakeTrick":
        if (game.phase != HeartsPhase.play) {
          return false;
        }

        // There must be 4 cards played.
        return game.allPlayed;
      case "Ready":
        if (game.hasGameEnded) {
          return false;
        }
        if (game.phase != HeartsPhase.score) {
          return false;
        }
        return true;
      default:
        print(data);
        assert(false); // How could this have happened?
        return false;
    }
  }

  @override
  void execute(Game g) {
    HeartsGame game = g as HeartsGame;

    print("HeartsCommand is executing: $data");
    List<String> parts = data.split(":");
    switch (phase) {
      case "Deal":
        if (game.phase != HeartsPhase.deal) {
          throw new StateError(
              "Cannot process deal commands when not in Deal phase");
        }
        // Deal appends cards to playerId's hand.
        int playerId = int.parse(parts[0]);
        List<Card> hand = game.cardCollections[playerId];
        if (hand.length + parts.length - 3 > 13) {
          throw new StateError("Cannot deal more than 13 cards to a hand");
        }

        // The last part is 'END', but the rest are cards.
        for (int i = 1; i < parts.length - 1; i++) {
          Card c = new Card.fromString(parts[i]);
          this.transfer(game.deck, hand, c);
        }
        return;
      case "Pass":
        if (game.phase != HeartsPhase.pass) {
          throw new StateError(
              "Cannot process pass commands when not in Pass phase");
        }
        // Pass moves a set of cards from senderId to receiverId.
        int senderId = int.parse(parts[0]);
        int receiverId = senderId + HeartsGame.offsetPass;
        List<Card> handS = game.cardCollections[senderId];
        List<Card> handR = game.cardCollections[receiverId];

        int numPassing = parts.length - 2; // not senderId and not end
        if (numPassing != 3) {
          throw new StateError("Must pass 3 cards, attempted $numPassing");
        }

        // The last part is 'END', but the rest are cards.
        for (int i = 1; i < parts.length - 1; i++) {
          Card c = new Card.fromString(parts[i]);
          this.transfer(handS, handR, c);
        }
        return;
      case "Take":
        if (game.phase != HeartsPhase.take) {
          throw new StateError(
              "Cannot process take commands when not in Take phase");
        }
        int takerId = int.parse(parts[0]);
        int senderPile = game.getTakeTarget(takerId) + HeartsGame.offsetPass;
        List<Card> handT = game.cardCollections[takerId];
        List<Card> handS = game.cardCollections[senderPile];
        handT.addAll(handS);
        handS.clear();
        return;
      case "Play":
        if (game.phase != HeartsPhase.play) {
          throw new StateError(
              "Cannot process play commands when not in Play phase");
        }

        // Can play if the game is asking for a card to be played.
        if (!game.asking) {
          throw new StateError("Cannot play if not asking");
        }

        // Play the card from the player's hand to their play pile.
        int playerId = int.parse(parts[0]);
        int targetId = playerId + HeartsGame.offsetPlay;
        List<Card> hand = game.cardCollections[playerId];
        List<Card> discard = game.cardCollections[targetId];

        Card c = new Card.fromString(parts[1]);

        // If the card isn't valid, then we have an error.
        String reason = game.canPlay(playerId, c);
        if (reason != null) {
          throw new StateError(
              "Player $playerId cannot play ${c.toString()} because $reason");
        }
        this.transfer(hand, discard, c);
        game.asking = false;
        return;
      case "Ask":
        if (game.phase != HeartsPhase.play) {
          throw new StateError(
              "Cannot process ask commands when not in Play phase");
        }
        if (game.asking) {
          throw new StateError("Cannot ask while already asking");
        }
        if (game.allPlayed) {
          throw new StateError("Cannot ask if all cards are played");
        }
        game.asking = true;
        return;
      case "TakeTrick":
        if (game.phase != HeartsPhase.play) {
          throw new StateError(
              "Cannot process take trick commands when not in Play phase");
        }
        if (!game.allPlayed) {
          throw new StateError(
              "Cannot take trick when some players have not played");
        }

        // Determine who won this trick.
        int winner = game.determineTrickWinner();

        // Move the cards to their trick list. Also check if hearts was broken.
        // Note: While some variants of Hearts allow the QUEEN_OF_SPADES to
        // break hearts, this version does NOT implement that rule.
        for (int i = 0; i < 4; i++) {
          List<Card> play = game.cardCollections[i + HeartsGame.offsetPlay];
          if (!game.heartsBroken && game.isHeartsCard(play[0])) {
            game.heartsBroken = true;
          }
          game.cardCollections[winner + HeartsGame.offsetTrick]
              .addAll(play); // or add(play[0])
          play.clear();
        }

        // Set them as the next person to go.
        game.lastTrickTaker = winner;
        game.trickNumber++;

        return;
      case "Ready":
        if (game.hasGameEnded) {
          throw new StateError(
              "Game has already ended. Start a new one to play again.");
        }
        if (game.phase != HeartsPhase.score) {
          throw new StateError(
              "Cannot process ready commands when not in Score phase");
        }
        int playerId = int.parse(parts[0]);
        game.setReady(playerId);
        return;
      default:
        print(data);
        assert(false); // How could this have happened?
    }
  }

  void transfer(List<Card> sender, List<Card> receiver, Card c) {
    if (!sender.contains(c)) {
      throw new StateError(
          "Sender ${sender.toString()} lacks Card ${c.toString()}");
    }
    sender.remove(c);
    receiver.add(c);
  }

  bool transferCheck(List<Card> sender, List<Card> receiver, Card c) {
    return sender.contains(c);
  }
}