// 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 'dart:math' as math;
import 'dart:async';

import 'package:flutter/material.dart';
import 'package:vector_math/vector_math_64.dart' as vector_math;

import '../logic/card.dart' as logic_card;
import '../logic/croupier.dart' show Croupier;
import '../logic/game/game.dart' show Game, GameType;
import '../logic/hearts/hearts.dart' show HeartsGame, HeartsPhase;
import '../sound/sound_assets.dart';
import '../styles/common.dart' as style;
import 'card.dart' as component_card;
import 'card_collection.dart'
    show CardCollectionComponent, CardCollectionOrientation, DropType, AcceptCb;
import 'croupier_profile.dart' show CroupierProfileComponent;

const double defaultBoardHeight = 400.0;
const double defaultBoardWidth = 400.0;
const double defaultCardHeight = 40.0;
const double defaultCardWidth = 40.0;

/// A Board represents a fixed-size canvas for drawing a Game's UI.
/// While other Widgets may be drawn to accomodate space, a Board is meant to
/// consume a specific amount of space on the screen, which allows for more
/// control when positioning elements within the Board's area.
abstract class Board extends StatefulWidget {
  Board(this.game,
      {double height, double width, double cardHeight, double cardWidth})
      : _height = height,
        _width = width,
        _cardHeight = cardHeight,
        _cardWidth = cardWidth;

  final Game game;
  final double _height;
  final double _width;
  final double _cardHeight;
  final double _cardWidth;

  double get height => _height ?? defaultBoardHeight;
  double get width => _width ?? defaultBoardWidth;
  double get cardHeight => _cardHeight ?? defaultCardHeight;
  double get cardWidth => _cardWidth ?? defaultCardWidth;
}

/// The HeartsBoard represents the Hearts table view, which shows the number of
/// cards each player has, and the cards they are currently playing.
class HeartsBoard extends Board {
  HeartsBoard(Croupier croupier, this.sounds,
      {double height,
      double width,
      double cardHeight,
      double cardWidth,
      this.isMini: false,
      this.gameAcceptCallback,
      this.setGameStateCallback,
      this.bufferedPlay})
      : croupier = croupier,
        super(croupier.game,
            height: height,
            width: width,
            cardHeight: cardHeight,
            cardWidth: cardWidth) {
    assert(this.game is HeartsGame);
  }

  final Croupier croupier;
  final SoundAssets sounds;
  final bool isMini;
  final AcceptCb gameAcceptCallback;
  final VoidCallback setGameStateCallback;
  final List<logic_card.Card> bufferedPlay;

  @override
  HeartsGame get game => super.game;

  @override
  HeartsBoardState createState() => new HeartsBoardState();
}

class HeartsBoardState extends State<HeartsBoard> {
  static const double PROFILE_SIZE = 0.17; // multiplier of config.height

  // Every time the counter changes, a sound will be played.
  // For example, in the pass/take phase, the counter does this:
  // 0->1->2->3->4->3->2->1->0.
  // We play 4 whooshIn sounds followed by 4 whooshOut sounds upon detecting
  // the change. Each sound only occurs during the very first build (the first
  // opportunity to detect the change).
  // In the play phase, we have this instead: 0->1->2->3->4->0
  // This 5-cycle is 4 played cards (whooshIn) and 1 take trick (whooshOut).
  int cardCounter = 0;
  bool passing = true;

  // Used to hide the cards played until it has been incremented enough.
  int localAsking = 0;

  void _handleCardCounterSounds() {
    // Ensure we have the right state while we deal and score.
    if (config.game.phase == HeartsPhase.deal ||
        config.game.phase == HeartsPhase.score) {
      cardCounter = 0;
      passing = true;
    }

    // Passing
    if (passing) {
      // If it is now someone's turn, we should no longer be passing.
      if (config.game.whoseTurn != null) {
        passing = false;

        // Special: Play a sound for the last take command of the pass phase.
        if (cardCounter > 0) {
          cardCounter = 0;
          _playSoundOut();
        }
        return;
      }

      // Passing: If somebody passed cards recently...
      if (config.game.numPassed > cardCounter) {
        cardCounter = config.game.numPassed;
        _playSoundIn();
        return;
      }

      // Passing: If somebody took cards recently...
      if (config.game.numPassed < cardCounter) {
        cardCounter = config.game.numPassed;
        _playSoundOut();
        return;
      }
      return;
    }

    // Playing: If somebody played a card...
    if (config.game.numPlayed > cardCounter) {
      cardCounter = config.game.numPlayed;
      _playSoundIn();
      return;
    }

    // Playing: If somebody took the trick...
    if (config.game.numPlayed == 0 && cardCounter != 0) {
      cardCounter = 0;
      _playSoundOut();
    }
  }

  void _playSoundIn() {
    if (!config.isMini) {
      config.sounds.play("whooshIn");
    }
  }

  void _playSoundOut() {
    if (!config.isMini) {
      config.sounds.play("whooshOut");
    }
  }

  @override
  Widget build(BuildContext context) {
    double offscreenDelta = config.isMini ? 5.0 : 1.5;

    _handleCardCounterSounds();
    _handleLocalAskingReset();

    Widget boardChild;
    if (config.game.phase == HeartsPhase.play) {
      boardChild =
          config.isMini ? _buildMiniBoardLayout() : _buildBoardLayout();
    } else {
      boardChild = _buildPassLayout();
    }

    return new Container(
        height: config.height,
        width: config.width,
        child: new Stack(children: [
          new Positioned(top: 0.0, left: 0.0, child: boardChild),
          new Positioned(
              top: config.height * (offscreenDelta + 0.5),
              left: (config.width - config.cardWidth) / 2,
              child: _buildOffScreenCards(
                  config.isMini ? rotateByGamePlayerNumber(0) : 0)), // bottom
          new Positioned(
              top: (config.height - config.cardHeight) / 2,
              left: config.width * (-offscreenDelta + 0.5),
              child: _buildOffScreenCards(
                  config.isMini ? rotateByGamePlayerNumber(1) : 1)), // left
          new Positioned(
              top: config.height * (-offscreenDelta + 0.5),
              left: (config.width - config.cardWidth) / 2,
              child: _buildOffScreenCards(
                  config.isMini ? rotateByGamePlayerNumber(2) : 2)), // top
          new Positioned(
              top: (config.height - config.cardHeight) / 2,
              left: config.width * (offscreenDelta + 0.5),
              child: _buildOffScreenCards(
                  config.isMini ? rotateByGamePlayerNumber(3) : 3)) // right
        ]));
  }

  int rotateByGamePlayerNumber(int i) {
    return (i + config.game.playerNumber) % 4;
  }

  static Map<int, String> passBackgrounds = const <int, String>{
    0: "images/games/hearts/pass_right.png",
    1: "images/games/hearts/pass_left.png",
    2: "images/games/hearts/pass_across.png",
    3: "",
  };

  Widget _buildPassLayout() {
    String passBackground = ""; // It's possible to have no background.
    if (config.game.phase == HeartsPhase.pass ||
        config.game.phase == HeartsPhase.take) {
      passBackground = passBackgrounds[config.game.roundNumber % 4];
    }

    return new Container(
        height: config.height,
        width: config.width,
        child: new Stack(children: [
          new Positioned(
              top: 0.0,
              left: 0.0,
              child: new AssetImage(
                  name: passBackground,
                  height: config.height,
                  width: config.width)),
          new Positioned(top: 0.0, left: 0.0, child: _buildPassLayoutInternal())
        ]));
  }

  double _rotationAngle(int pNum) {
    return pNum * math.PI / 2;
  }

  Widget _rotate(Widget w, int pNum) {
    return new Transform(
        child: w,
        transform:
            new vector_math.Matrix4.identity().rotateZ(_rotationAngle(pNum)),
        alignment: new FractionalOffset(0.5, 0.5));
  }

  Widget _getPass(int playerNumber) {
    double sizeRatio = 0.10;
    double cccSize = math.min(sizeRatio * config.width, config.cardWidth * 3.5);

    HeartsGame game = config.game;
    List<logic_card.Card> cardsToTake = [];
    int takeTarget = game.getTakeTarget(playerNumber);
    if (takeTarget != null) {
      cardsToTake = game.cardCollections[
          game.getTakeTarget(playerNumber) + HeartsGame.offsetPass];
    }

    bool isHorz = playerNumber % 2 == 0;
    CardCollectionOrientation ori = isHorz
        ? CardCollectionOrientation.horz
        : CardCollectionOrientation.vert;
    return new CardCollectionComponent(cardsToTake, false, ori,
        backgroundColor: style.transparentColor,
        width: isHorz ? cccSize : null,
        height: isHorz ? null : cccSize,
        widthCard: config.cardWidth,
        heightCard: config.cardHeight,
        rotation: playerNumber * math.PI / 2,
        useKeys: true);
  }

  Widget _getProfile(int pNum, double sizeFactor) {
    return new CroupierProfileComponent.horizontal(
        settings: config.croupier.settingsFromPlayerNumber(pNum));
  }

  Widget _playerProfile(int pNum, double sizeFactor) {
    return _rotate(_getProfile(pNum, sizeFactor), pNum);
  }

  Widget _buildPassLayoutInternal() {
    return new Container(
        height: config.height,
        width: config.width,
        child: new Column(
            children: [
              new Flexible(child: _playerProfile(2, PROFILE_SIZE), flex: 0),
              new Flexible(child: _getPass(2), flex: 0),
              new Flexible(
                  child: new Row(
                      children: [
                        new Flexible(
                            child: _playerProfile(1, PROFILE_SIZE), flex: 0),
                        new Flexible(child: _getPass(1), flex: 0),
                        new Flexible(child: new Block(children: []), flex: 1),
                        new Flexible(child: _getPass(3), flex: 0),
                        new Flexible(
                            child: _playerProfile(3, PROFILE_SIZE), flex: 0)
                      ],
                      crossAxisAlignment: CrossAxisAlignment.center,
                      mainAxisAlignment: MainAxisAlignment.spaceAround),
                  flex: 1),
              new Flexible(child: _getPass(0), flex: 0),
              new Flexible(child: _playerProfile(0, PROFILE_SIZE), flex: 0)
            ],
            crossAxisAlignment: CrossAxisAlignment.center,
            mainAxisAlignment: MainAxisAlignment.spaceAround));
  }

  Widget _buildMiniBoardLayout() {
    return new Container(
        height: config.height,
        width: config.width,
        child: new Center(child: new Row(children: [
          new Flexible(
              flex: 1,
              child: new Center(
                  child: _buildAvatarSlotCombo(rotateByGamePlayerNumber(1)))),
          new Flexible(
              flex: 1,
              child: new Column(children: [
                new Flexible(
                    flex: 1,
                    child: _buildAvatarSlotCombo(rotateByGamePlayerNumber(2))),
                new Flexible(
                    flex: 1,
                    child: _buildAvatarSlotCombo(rotateByGamePlayerNumber(0)))
              ])),
          new Flexible(
              flex: 1,
              child: new Center(
                  child: _buildAvatarSlotCombo(rotateByGamePlayerNumber(3))))
        ])));
  }

  Widget _buildAvatarSlotCombo(int playerNumber) {
    HeartsGame game = config.game;
    int p = game.playerNumber;

    List<Widget> items = new List<Widget>();
    bool isMe = playerNumber == p;

    List<logic_card.Card> showCard =
        game.cardCollections[playerNumber + HeartsGame.offsetPlay];
    bool hasPlayed = showCard.length > 0;
    bool isTurn = playerNumber == game.whoseTurn && !hasPlayed;
    if (isMe && config.bufferedPlay != null) {
      showCard = config.bufferedPlay;
    }

    items.add(new Positioned(
        top: 0.0,
        left: 0.0,
        child: new CardCollectionComponent(
            showCard, true, CardCollectionOrientation.show1,
            useKeys: true,
            acceptCallback: config.gameAcceptCallback,
            acceptType: isMe && !hasPlayed ? DropType.card : DropType.none,
            widthCard: config.cardWidth - 6.0,
            heightCard: config.cardHeight - 6.0,
            backgroundColor:
                isTurn ? style.theme.accentColor : Colors.grey[500],
            altColor: isTurn ? Colors.grey[200] : Colors.grey[600])));

    if (!hasPlayed) {
      items.add(new Positioned(
          top: 0.0,
          left: 0.0,
          child: new IgnorePointer(child: new CroupierProfileComponent.mini(
              settings: config.croupier.settingsFromPlayerNumber(playerNumber),
              height: config.cardHeight,
              width: config.cardWidth))));
    }

    return new Container(
        width: config.cardWidth,
        height: config.cardHeight,
        child: new Stack(children: items));
  }

  Widget _showTrickText(int pNum) {
    HeartsGame game = config.game;

    int numTrickCards =
        game.cardCollections[HeartsGame.offsetTrick + pNum].length;
    int numTricks = numTrickCards ~/ 4;

    String s = numTricks != 1 ? "s" : "";

    return _rotate(new Text("$numTricks trick$s"), pNum);
  }

  void _handleLocalAskingReset() {
    // If the trick was taken, we can reset localAsking.
    if (config.game.numPlayed == 0) {
      localAsking = 0;
    }
  }

  bool _incrementLocalAsking() {
    if (localAsking < config.game.numPlayed) {
      setState(() {
        localAsking++;
        if (config.setGameStateCallback != null) {
          config.setGameStateCallback(); // Required for ZCards to redraw.
        }
      });
      return true;
    }
    return false;
  }

  void _boardLayoutTapCb() {
    // You can tap anywhere on the board to fake "Ask" or "Take Trick".
    if (localAsking < 4) {
      // Try to increment. If it fails, be lenient! Give 0.5 seconds to check
      // this condition again.
      if (!_incrementLocalAsking()) {
        new Future.delayed(const Duration(milliseconds: 500), () {
          _incrementLocalAsking(); // give it one more shot
        });
      }
    } else {
      config.game.takeTrickUI();
    }
  }

  Widget _buildBoardLayout() {
    int activePlayer = config.game.allPlayed
        ? config.game.determineTrickWinner()
        : config.game.whoseTurn;

    return new GestureDetector(
        onTap: _boardLayoutTapCb,
        child: new Container(
            height: config.height,
            width: config.width,
            decoration: new BoxDecoration(border: new Border(
                top: new BorderSide(
                    color: activePlayer == 2
                        ? style.theme.accentColor
                        : style.transparentColor,
                    width: 5.0),
                right: new BorderSide(
                    color: activePlayer == 3
                        ? style.theme.accentColor
                        : style.transparentColor,
                    width: 5.0),
                left: new BorderSide(
                    color: activePlayer == 1
                        ? style.theme.accentColor
                        : style.transparentColor,
                    width: 5.0),
                bottom: new BorderSide(
                    color: activePlayer == 0
                        ? style.theme.accentColor
                        : style.transparentColor,
                    width: 5.0))),
            child: new Column(
                children: [
                  new Flexible(child: _playerProfile(2, PROFILE_SIZE), flex: 0),
                  new Flexible(child: _showTrickText(2), flex: 0),
                  new Flexible(
                      child: new Row(
                          children: [
                            new Flexible(
                                child: _playerProfile(1, PROFILE_SIZE),
                                flex: 0),
                            new Flexible(child: _showTrickText(1), flex: 0),
                            new Flexible(
                                child: new Center(child: _buildCenterCards()),
                                flex: 1),
                            new Flexible(child: _showTrickText(3), flex: 0),
                            new Flexible(
                                child: _playerProfile(3, PROFILE_SIZE), flex: 0)
                          ],
                          crossAxisAlignment: CrossAxisAlignment.center,
                          mainAxisAlignment: MainAxisAlignment.spaceAround),
                      flex: 1),
                  new Flexible(child: _showTrickText(0), flex: 0),
                  new Flexible(child: _playerProfile(0, PROFILE_SIZE), flex: 0)
                ],
                crossAxisAlignment: CrossAxisAlignment.center,
                mainAxisAlignment: MainAxisAlignment.spaceAround)));
  }

  Widget _buildCenterCards() {
    double height = config.cardHeight * this._centerScaleFactor;
    double width = config.cardWidth * this._centerScaleFactor;
    Widget centerPiece = new Container(
        height: height, width: width, child: new Block(children: []));
    if (localAsking == 4) {
      // If all cards played are revealed, show Take Trick button.
      int rotateNum = config.game.determineTrickWinner();
      double smaller = math.min(height, width);

      // TODO(alexfandrianto): The Text looks great within the square
      // container, but this is supposed to be pressable like a button.
      // The reason why I did it this way is that the button's disappearance
      // prevents the board's onTap handler from firing.
      // https://github.com/flutter/flutter/issues/1497
      centerPiece = _rotate(
          new Container(
              height: smaller,
              width: smaller,
              decoration: style.Box.liveBackground,
              child: new Center(
                  child: new Text("Take", style: style.Text.largeStyle))),
          rotateNum);
    }

    return new Column(
        children: [
          new Flexible(child: new Row(
              children: [
                new Flexible(child: new Block(children: [])),
                new Flexible(child: new Center(child: _buildCenterCard(2))),
                new Flexible(child: new Block(children: [])),
              ],
              crossAxisAlignment: CrossAxisAlignment.center,
              mainAxisAlignment: MainAxisAlignment.center)),
          new Flexible(child: new Row(
              children: [
                new Flexible(child: new Center(child: _buildCenterCard(1))),
                new Flexible(child: new Row(
                    children: [centerPiece],
                    crossAxisAlignment: CrossAxisAlignment.center,
                    mainAxisAlignment: MainAxisAlignment.center)),
                new Flexible(child: new Center(child: _buildCenterCard(3))),
              ],
              crossAxisAlignment: CrossAxisAlignment.center,
              mainAxisAlignment: MainAxisAlignment.center)),
          new Flexible(child: new Row(
              children: [
                new Flexible(child: new Block(children: [])),
                new Flexible(child: new Center(child: _buildCenterCard(0))),
                new Flexible(child: new Block(children: [])),
              ],
              crossAxisAlignment: CrossAxisAlignment.center,
              mainAxisAlignment: MainAxisAlignment.center))
        ],
        crossAxisAlignment: CrossAxisAlignment.center,
        mainAxisAlignment: MainAxisAlignment.center);
  }

  double get _centerScaleFactor {
    bool wide = (config.width >= config.height);
    double heightUsed = 2 * PROFILE_SIZE;

    if (wide) {
      return config.height * (1 - heightUsed) / (config.cardHeight * 4);
    } else {
      return (config.width - (1.5 * config.height * heightUsed)) /
          (config.cardWidth * 4);
    }
  }

  Widget _buildCenterCard(int playerNumber) {
    HeartsGame game = config.game;
    List<logic_card.Card> cards =
        game.cardCollections[playerNumber + HeartsGame.offsetPlay];

    // TODO(alexfandrianto): Clean up soon.
    // https://github.com/vanadium/issues/issues/1098
    //bool hasPlayed = cards.length > 0;
    //bool isTurn = game.whoseTurn == playerNumber && !hasPlayed;

    double height = config.cardHeight * this._centerScaleFactor;
    double width = config.cardWidth * this._centerScaleFactor;

    bool canShow =
        (playerNumber - config.game.lastTrickTaker) % 4 < localAsking;

    List<Widget> stackWidgets = <Widget>[
      new Positioned(
          top: 0.0,
          left: 0.0,
          child: new CardCollectionComponent(
              cards, canShow, CardCollectionOrientation.show1,
              widthCard: width - 6,
              heightCard: height - 6,
              rotation: _rotationAngle(playerNumber),
              useKeys: true))
    ];

    // TODO(alexfandrianto): Clean up soon.
    // https://github.com/vanadium/issues/issues/1098
    /*if (isTurn) {
      stackWidgets.add(new Positioned(
          top: 0.0,
          left: 0.0,
          child: _rotate(
              new Container(
                  height: height,
                  width: width,
                  child: new RaisedButton(
                      child: new Text("Play", style: style.Text.largeStyle),
                      onPressed: config.game.asking ? null : config.game.askUI,
                      color: style.theme.accentColor)),
              playerNumber)));
    }*/

    return new Container(
        height: height, width: width, child: new Stack(children: stackWidgets));
  }

  // The off-screen cards consist of trick cards and play cards.
  // When the board is mini, the player's play cards are excluded.
  Widget _buildOffScreenCards(int playerNumber) {
    HeartsGame game = config.game;

    List<logic_card.Card> cards = new List.from(
        game.cardCollections[playerNumber + HeartsGame.offsetTrick]);

    bool isPlay = game.phase == HeartsPhase.play;

    // Prevent over-expansion of cards until a card has been played.
    bool alreadyPlaying =
        (isPlay && (game.numPlayed > 0 || game.trickNumber > 0));

    double sizeFactor = 1.0;
    if (config.isMini) {
      if (playerNumber != game.playerNumber) {
        cards
            .addAll(game.cardCollections[playerNumber + HeartsGame.offsetHand]);
      }
    } else {
      cards.addAll(game.cardCollections[playerNumber + HeartsGame.offsetHand]);

      if (alreadyPlaying) {
        sizeFactor = this._centerScaleFactor;
      }
    }

    return new CardCollectionComponent(
        cards, alreadyPlaying, CardCollectionOrientation.show1,
        widthCard: config.cardWidth * sizeFactor,
        heightCard: config.cardHeight * sizeFactor,
        useKeys: true,
        rotation: config.isMini ? null : _rotationAngle(playerNumber),
        animationType: component_card.CardAnimationType.long);
  }
}