// 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.

import "package:test/test.dart";
import "../lib/logic/solitaire/solitaire.dart";
import "../lib/logic/card.dart";

import "dart:io";

typedef bool KeepGoingCb();

KeepGoingCb makeCommandReader(SolitaireGame game, String filename) {
  File file = new File(filename);
  List<String> commands = file.readAsStringSync().split("\n");
  int commandIndex = 0;

  KeepGoingCb runCommand;

  runCommand = () {
    if (commandIndex >= commands.length) {
      return false;
    }
    String c = commands[commandIndex];
    commandIndex++;
    if (c == "" || c[0] == "#") {
      // Essentially, this case allows empty lines and comments.
      return runCommand();
    }
    game.gamelog.add(new SolitaireCommand.fromCommand(c));

    return commandIndex < commands.length;
  };

  return runCommand;
}

void main() {
  group("Initialization", () {
    SolitaireGame game = new SolitaireGame(0);
    test("Dealing", () {
      game.dealCardsUI(); // What we run when starting the game.

      // By virtue of creating the game, SolitaireGame should have:
      // 0 in each Ace pile
      // 0 in the discard and 24 in the draw pile
      // 0 to 6 in each down pile
      // 1 in each up pile
      for (int i = 0; i < 4; i++) {
        expect(game.cardCollections[SolitaireGame.OFFSET_ACES + i].length,
            equals(0),
            reason: "Ace piles start empty");
      }
      expect(
          game.cardCollections[SolitaireGame.OFFSET_DISCARD].length, equals(0),
          reason: "Discard pile starts empty");
      expect(game.cardCollections[SolitaireGame.OFFSET_DRAW].length, equals(24),
          reason: "Draw pile gets the remaining 24 cards");

      for (int i = 0; i < 7; i++) {
        expect(game.cardCollections[SolitaireGame.OFFSET_DOWN + i].length,
            equals(i),
            reason: "Down pile ${i} starts with ${i} cards");
        expect(
            game.cardCollections[SolitaireGame.OFFSET_UP + i].length, equals(1),
            reason: "Up piles start with 1 card");
      }
    });
  });

  // We have a debug cheat button that lets you advance in the game.
  // After calling it once, it is forced to place cards up into the aces area.
  group("Cheat Command", () {
    SolitaireGame game = new SolitaireGame(0);
    game.dealCardsUI(); // Get the cards out there.

    test("Cheat Functionality", () {
      for (int cheatNum = 0; cheatNum < 13; cheatNum++) {
        game.cheatUI();
        for (int i = 0; i < 4; i++) {
          expect(game.cardCollections[SolitaireGame.OFFSET_ACES + i].length,
              equals(cheatNum + 1));
        }
      }

      expect(game.isGameWon, isTrue);

      game.cheatUI(); // Should not error
      expect(game.isGameWon, isTrue); // We still win.
    });
  });

  group("Check Endgame", () {
    SolitaireGame game = new SolitaireGame(0);

    test("Has not won pre-deal", () {
      expect(game.phase, equals(SolitairePhase.Deal));
      expect(game.isGameWon, isFalse);
    });

    test("Has not won immediately after deal", () {
      game.dealCardsUI(); // What we run when starting the game.
      expect(game.phase, equals(SolitairePhase.Play));
      expect(game.isGameWon, isFalse);
    });

    test("Wins with all cards placed - regardless of order", () {
      for (int i = 0; i < 13; i++) {
        game.cheatUI(); // What we run when cheating.
      }
      expect(game.phase, equals(SolitairePhase.Score));
      expect(game.isGameWon, isTrue);

      // Now check an alternative suit order.
      List<Card> aces0 =
          new List<Card>.from(game.cardCollections[SolitaireGame.OFFSET_ACES]);
      List<Card> aces1 = new List<Card>.from(
          game.cardCollections[SolitaireGame.OFFSET_ACES + 1]);

      game.cardCollections[SolitaireGame.OFFSET_ACES].clear();
      game.cardCollections[SolitaireGame.OFFSET_ACES + 1].clear();

      // This expectation can be removed if isGameWon becomes a parameter, as
      // opposed to a computed property. However, if that happens, this test
      // will need to be reworked too, to start with a fresh game.
      expect(game.isGameWon, isFalse);

      // Swap the piles
      game.cardCollections[SolitaireGame.OFFSET_ACES].addAll(aces1);
      game.cardCollections[SolitaireGame.OFFSET_ACES + 1].addAll(aces0);

      expect(game.isGameWon, isTrue);
    });
  });

  // Run through a canonical game of Solitaire where the player doesn't win.
  group("Solitaire - Loss", () {
    SolitaireGame game = new SolitaireGame(0);

    // Note: This could have been a non-file (in-memory), but it's fine to use a file too.
    KeepGoingCb runCommand =
        makeCommandReader(game, "test/game_log_solitaire_test_loss.txt");

    test("Solitaire Commands", () {
      bool keepGoing = true;
      for (int i = 0; keepGoing; i++) {
        if (i == 0) {
          expect(game.phase, equals(SolitairePhase.Deal));
        } else if (!game.isGameWon) {
          expect(game.phase, equals(SolitairePhase.Play));
        } else {
          expect(game.phase, equals(SolitairePhase.Score));
        }

        // Play the next step of the game until we run out.
        keepGoing = runCommand(); // Must not error.
      }
    });

    // Naturally, we should ensure that we haven't won the game.
    test("Solitaire Win == False", () {
      expect(game.isGameWon, isFalse);
      expect(game.phase, equals(SolitairePhase.Play));
    });
  });

  // Run through a canonical game of Solitaire where the player does win.
  group("Solitaire - Win", () {
    SolitaireGame game = new SolitaireGame(0);

    // Note: This could have been a non-file (in-memory), but it's fine to use a file too.
    KeepGoingCb runCommand =
        makeCommandReader(game, "test/game_log_solitaire_test_win.txt");

    test("Solitaire Commands", () {
      bool keepGoing = true;
      for (int i = 0; keepGoing; i++) {
        if (i == 0) {
          expect(game.phase, equals(SolitairePhase.Deal));
        } else if (!game.isGameWon) {
          expect(game.phase, equals(SolitairePhase.Play));
        } else {
          expect(game.phase, equals(SolitairePhase.Score));
        }

        // Play the next step of the game until we run out.
        keepGoing = runCommand(); // Must not error.
      }
    });

    // Check that we won the game.
    test("Solitaire Win == True", () {
      expect(game.isGameWon, isTrue);
      expect(game.phase, equals(SolitairePhase.Score));
    });
  });

  group("Card Manipulation - Error Cases", () {
    test("Dealing - wrong phase", () {
      expect(() {
        SolitaireGame game = new SolitaireGame(0);
        game.phase = SolitairePhase.Score;
        game.gamelog
            .add(new SolitaireCommand.deal(new List<Card>.from(Card.All)));
      }, throwsA(new isInstanceOf<StateError>()));
    });
    test("Dealing - fake cards", () {
      expect(() {
        SolitaireGame game = new SolitaireGame(0);
        game.gamelog.add(
            new SolitaireCommand.deal(<Card>[new Card("fake", "not real")]));
      }, throwsA(new isInstanceOf<StateError>()));
    });
    test("Dealing - wrong number of cards dealt", () {
      // 2x as many cards
      expect(() {
        SolitaireGame game = new SolitaireGame(0);
        game.gamelog.add(new SolitaireCommand.deal(
            new List<Card>.from(Card.All)..addAll(Card.All)));
      }, throwsA(new isInstanceOf<StateError>()));
      // missing cards
      expect(() {
        SolitaireGame game = new SolitaireGame(0);
        game.gamelog.add(new SolitaireCommand.deal(
            new List<Card>.from(Card.All.getRange(0, 40))));
      }, throwsA(new isInstanceOf<StateError>()));
    });

    // Set up an arbitrary game state (manually) that allows testing of many
    // error cases.
    test("Playing - cannot move", () {
      // The setup will be this:
      // s2 _ h2 _   d2 c11
      // _ c3 h3 d1 s13 d3 d12

      Card c3 = Card.All[0 + 2];
      Card c11 = Card.All[0 + 10];
      Card d1 = Card.All[13 + 0];
      Card d2 = Card.All[13 + 1];
      Card d3 = Card.All[13 + 2];
      Card h2 = Card.All[26 + 1];
      Card h3 = Card.All[26 + 2];
      Card d12 = Card.All[13 + 11];
      Card s2 = Card.All[39 + 1];
      Card s13 = Card.All[39 + 12];

      SolitaireGame _makeArbitrarySolitaireGame() {
        SolitaireGame g = new SolitaireGame(0);

        // Top row
        g.cardCollections[SolitaireGame.OFFSET_ACES].add(s2);
        g.cardCollections[SolitaireGame.OFFSET_ACES + 2].add(h2);
        g.cardCollections[SolitaireGame.OFFSET_DISCARD].add(d2);
        g.cardCollections[SolitaireGame.OFFSET_DRAW].add(c11);

        // Bottom row
        g.cardCollections[SolitaireGame.OFFSET_UP + 1].add(c3);
        g.cardCollections[SolitaireGame.OFFSET_UP + 2].add(h3);
        g.cardCollections[SolitaireGame.OFFSET_UP + 3].add(d1);
        g.cardCollections[SolitaireGame.OFFSET_UP + 4].add(s13);
        g.cardCollections[SolitaireGame.OFFSET_UP + 5].add(d3);
        g.cardCollections[SolitaireGame.OFFSET_UP + 6].add(d12);

        g.phase = SolitairePhase.Play;

        return g;
      }

      // Cannot move d1 up to empty ACES slot if not in Play phase.
      expect(() {
        SolitaireGame game = _makeArbitrarySolitaireGame();
        game.phase = SolitairePhase.Deal;
        game.gamelog
            .add(new SolitaireCommand.move(d1, SolitaireGame.OFFSET_ACES + 1));
      }, throwsA(new isInstanceOf<StateError>()));

      // Cannot move d1 to nonexistent slot.
      expect(() {
        SolitaireGame game = _makeArbitrarySolitaireGame();
        game.gamelog.add(new SolitaireCommand.move(d1, -1));
      }, throwsA(new isInstanceOf<StateError>()));

      // Cannot move d1 to ACES slot that is used.
      expect(() {
        SolitaireGame game = _makeArbitrarySolitaireGame();
        game.gamelog
            .add(new SolitaireCommand.move(d1, SolitaireGame.OFFSET_ACES + 2));
      }, throwsA(new isInstanceOf<StateError>()));

      // However, we can move d1 to the unused ACES slot in the Play phase.
      // see the end.

      // We cannot move c11 to d12 because it's in the DRAW pile still.
      expect(() {
        SolitaireGame game = _makeArbitrarySolitaireGame();
        game.gamelog
            .add(new SolitaireCommand.move(c11, SolitaireGame.OFFSET_UP + 6));
      }, throwsA(new isInstanceOf<StateError>()));

      // We cannot move d2 (discard) to the DRAW pile.
      expect(() {
        SolitaireGame game = _makeArbitrarySolitaireGame();
        game.gamelog
            .add(new SolitaireCommand.move(d2, SolitaireGame.OFFSET_DRAW));
      }, throwsA(new isInstanceOf<StateError>()));

      // We cannot move d1 (up) to the DISCARD pile either.
      expect(() {
        SolitaireGame game = _makeArbitrarySolitaireGame();
        game.gamelog
            .add(new SolitaireCommand.move(d1, SolitaireGame.OFFSET_DISCARD));
      }, throwsA(new isInstanceOf<StateError>()));

      // There are restrictions on what can be played on ACES piles.
      // First, suit mismatch: (h3 to spade ACE)
      expect(() {
        SolitaireGame game = _makeArbitrarySolitaireGame();
        game.gamelog
            .add(new SolitaireCommand.move(h3, SolitaireGame.OFFSET_ACES));
      }, throwsA(new isInstanceOf<StateError>()));

      // Next, non-ace on empty ACES slot. (c3 to empty ACE)
      expect(() {
        SolitaireGame game = _makeArbitrarySolitaireGame();
        game.gamelog
            .add(new SolitaireCommand.move(c3, SolitaireGame.OFFSET_ACES + 3));
      }, throwsA(new isInstanceOf<StateError>()));

      // Below, we'll show that moving to ACES works for various cases.

      // There are restrictions on what can be played on UP piles.
      // First, color that matches. (h2 to d3)
      expect(() {
        SolitaireGame game = _makeArbitrarySolitaireGame();
        game.gamelog
            .add(new SolitaireCommand.move(h2, SolitaireGame.OFFSET_ACES + 5));
      }, throwsA(new isInstanceOf<StateError>()));

      // Next, number that isn't 1 lower. (c3 to h3)
      expect(() {
        SolitaireGame game = _makeArbitrarySolitaireGame();
        game.gamelog
            .add(new SolitaireCommand.move(c3, SolitaireGame.OFFSET_ACES + 2));
      }, throwsA(new isInstanceOf<StateError>()));

      // Last, an empty that doesn't receive a king. (c3 to empty UP)
      expect(() {
        SolitaireGame game = _makeArbitrarySolitaireGame();
        game.gamelog
            .add(new SolitaireCommand.move(c3, SolitaireGame.OFFSET_ACES));
      }, throwsA(new isInstanceOf<StateError>()));

      // Below, we'll show that moving to UP works for various cases.

      // Success cases:
      // Going to ACES (empty) with an ace. (d1 to empty)
      // Going to ACES with a suit match. (h3 to h2, d2 to d1)
      // Going to UP with the color mismatch + 1 number lower. (d12 to s13, s2 to d3, d2 to c3)
      // Going to UP (empty) with a king. (s13 to empty)
      SolitaireGame game = _makeArbitrarySolitaireGame();
      game.gamelog
          .add(new SolitaireCommand.move(d1, SolitaireGame.OFFSET_ACES + 1));
      game.gamelog
          .add(new SolitaireCommand.move(h3, SolitaireGame.OFFSET_ACES + 2));
      game.gamelog
          .add(new SolitaireCommand.move(d2, SolitaireGame.OFFSET_ACES + 1));
      game.gamelog
          .add(new SolitaireCommand.move(d12, SolitaireGame.OFFSET_UP + 4));
      game.gamelog
          .add(new SolitaireCommand.move(s2, SolitaireGame.OFFSET_UP + 5));
      game.gamelog
          .add(new SolitaireCommand.move(d2, SolitaireGame.OFFSET_UP + 1));
      game.gamelog
          .add(new SolitaireCommand.move(s13, SolitaireGame.OFFSET_UP + 0));
    });

    // Consider various situations in which you cannot flip.
    test("Playing - cannot flip", () {
      // Wrong phase.
      expect(() {
        SolitaireGame game = new SolitaireGame(0);
        game.gamelog.add(new SolitaireCommand.flip(3));
      }, throwsA(new isInstanceOf<StateError>()));

      // Bad index (low)
      expect(() {
        SolitaireGame game = new SolitaireGame(0);

        // Deal first.
        game.dealCardsUI();

        // Remove some cards...
        game.cardCollections[SolitaireGame.OFFSET_UP + 1].clear();

        // Try to flip a pile that doesn't exist.
        game.gamelog.add(new SolitaireCommand.flip(-1));
      }, throwsA(new isInstanceOf<StateError>()));

      // Bad index (high)
      expect(() {
        SolitaireGame game = new SolitaireGame(0);

        // Deal first.
        game.dealCardsUI();

        // Remove some cards...
        game.cardCollections[SolitaireGame.OFFSET_UP + 1].clear();

        // Try to flip a pile that doesn't exist.
        game.gamelog.add(new SolitaireCommand.flip(7));
      }, throwsA(new isInstanceOf<StateError>()));

      // No down card to flip.
      expect(() {
        SolitaireGame game = new SolitaireGame(0);

        // Deal first.
        game.dealCardsUI();

        // Remove some cards...
        game.cardCollections[SolitaireGame.OFFSET_UP + 1].clear();
        game.cardCollections[SolitaireGame.OFFSET_DOWN + 1].clear();

        // Try to flip a pile that doesn't exist.
        game.gamelog.add(new SolitaireCommand.flip(1));
      }, throwsA(new isInstanceOf<StateError>()));

      // Up card is in the way.
      expect(() {
        SolitaireGame game = new SolitaireGame(0);

        // Deal first.
        game.dealCardsUI();

        // Do not clear out the area for pile 1.

        game.gamelog.add(new SolitaireCommand.flip(1));
      }, throwsA(new isInstanceOf<StateError>()));

      // This scenario should work though.
      SolitaireGame game = new SolitaireGame(0);

      // Deal. Clear away pile 1. Flip pile 1.
      game.dealCardsUI();
      game.cardCollections[SolitaireGame.OFFSET_UP + 1].clear();
      game.gamelog.add(new SolitaireCommand.flip(1));
    });

    // Consider various situations in which you cannot draw.
    test("Playing - cannot draw", () {
      // Wrong phase.
      expect(() {
        SolitaireGame game = new SolitaireGame(0);
        game.gamelog.add(new SolitaireCommand.draw());
      }, throwsA(new isInstanceOf<StateError>()));

      // No draw cards remain.
      expect(() {
        SolitaireGame game = new SolitaireGame(0);
        game.dealCardsUI();

        // Remove all draw cards.
        game.cardCollections[SolitaireGame.OFFSET_DRAW].clear();

        game.gamelog.add(new SolitaireCommand.draw());
      }, throwsA(new isInstanceOf<StateError>()));

      // But it should be fine to draw just after dealing.
      SolitaireGame game = new SolitaireGame(0);

      // Deal first.
      game.dealCardsUI();
      game.gamelog.add(new SolitaireCommand.draw());
    });
  });
}