#ifndef STRATEGYSKELETON_H
#define STRATEGYSKELETON_H
///////////////////////////////////////////////////////
// StrategySkeleton.h - Declare Strategy classes     //
//                                                   //
// Jim Fawcett, CSE776 - Design Patterns, Fall 2011  //
///////////////////////////////////////////////////////

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <string>

class Context
{
public:
  Context()
  {
    _pot = 0;         // money on table
    _bet = 0;         // current bet;
    srand( static_cast<unsigned int>(time(0)));
  }
  static size_t& pot() { return _pot; }
  static size_t& bet() { return _bet; }
  size_t dealCards()
  {
    return rand() % 10 + 1;  // return value of hand
  }
private:
  static size_t _pot;  // shared by all players
  static size_t _bet;  // shared by all players
};

class Strategy
{
public:
  enum action { fold, stay, raise };
  virtual action playHand(Player* players[]) = 0;
  virtual ~Strategy() {}
protected:
  Context* _pContext;
};

class AggressivePlay : public Strategy
{
public:
  AggressivePlay()
  {
    _pContext = new Context;  // all fields are static
  }
  action playHand(size_t& stake, size_t& bet, size_t handValue)
  {
    size_t pot = _pContext->pot();
    bet = _pContext->bet();

    // raise bet
    if(bet < static_cast<size_t>(0.2*stake) && handValue > 6)
    {
      size_t bump = static_cast<size_t>(0.1*stake);
      _pContext->bet() += bump;
      _pContext->pot() += (bet + bump);
      bet += bump;
      stake -= bet;
      return raise;
    }
    // stay - match bet
    if(_pContext->bet() < static_cast<size_t>(0.1*stake) && handValue > 4)
    {
      _pContext->pot() += bet;
      stake -= bet;
      return stay;
    }
    bet = 0;
    return fold;
  }
};

class ConservativePlay : public Strategy
{
public:
  ConservativePlay() 
  { 
    _pContext = new Context;  // all fields are static 
  }
  action playHand(size_t& stake, size_t& bet, size_t handValue)
  {
    size_t pot = _pContext->pot();
    bet = _pContext->bet();

    // raise bet
    if(bet < static_cast<size_t>(0.1*stake) && handValue > 8)
    {
      size_t bump = static_cast<size_t>(0.05*stake);
      _pContext->bet() += bump;
      _pContext->pot() +=( bet + bump);
      bet += bump;
      stake -= bet;
      return raise;
    }
    // stay - match bet
    if(_pContext->bet() < static_cast<size_t>(0.1*stake) && handValue > 5)
    {
      _pContext->pot() += bet;
      stake -= bet;
      return stay;
    }
    bet = 0;
    return fold;
  }
};

class Player
{
public:
  Player(std::string name, size_t stake)
  {
    _name = name;
    _stake = stake;
    _folded = false;
    _pAggressivePlay = new AggressivePlay;
    _pConservativePlay = new ConservativePlay;
    _pContext = new Context;
    if(stake > 100)
      _pStrategy = _pAggressivePlay;
    else
      _pStrategy = _pConservativePlay;
  }
  std::string name() { return _name; }
  Strategy::action playHand()
  {
    Strategy::action action = _pStrategy->playHand(this);
    if(_stake > 100)
      _pStrategy = _pAggressivePlay;
    else
      _pStrategy = _pConservativePlay;
    return action;
  }
  void dealCards()
  {
    _handValue = _pContext->dealCards();
  }
  size_t handValue() { return _handValue; }
  size_t& stake() { return _stake; }
  size_t& bet() { return _bet; }
  bool& folded() { return _folded; }
private:
  Strategy* _pStrategy;
  Strategy* _pAggressivePlay;
  Strategy* _pConservativePlay;
  Context* _pContext;
  size_t _handValue;
  size_t _stake;
  size_t _bet;
  std::string _name;
  bool _folded;
};

#endif