#include <iostream>
#include <string>
#include <vector>
#include <memory>

using namespace std;


enum class DamageTypeT { PHYSICAL, FIRE, ICE, MENTAL, NONE};
vector<string>DamageTypeName{"Physical", "Fire", "Ice", "Mental", "None"};

struct DamageT {
    DamageTypeT type;
    int amount;
};


class WeaponTBase {
    public:
       virtual vector<DamageT> Damage() const = 0;
       virtual int Cost() const = 0;
       virtual string Name()  const = 0;
       virtual int Hit() const = 0;
       virtual int MaxDamage() const = 0;
};

using WeaponPtr = shared_ptr<WeaponTBase>;

class WeaponT: public  WeaponTBase {
    public:
      WeaponT(int c, int d, string n,  DamageTypeT damageT):
          cost{c}, damageMax{d}, name{n}, damageType{damageT} {};


      vector<DamageT> Damage() const override{
          vector<DamageT> rv;
          DamageT result;
          result.type = damageType;
          result.amount = rand() % damageMax + 1;
          rv.push_back(result);
          return rv;
      }

      int Cost() const override {
          return cost;
      };

      string Name() const override { 
          return name;
      } ;

      int Hit() const override { return 0;};

      int MaxDamage() const  override{ return damageMax;};

    private:
      int cost;
      int damageMax;
      string name;
      DamageTypeT damageType;

};

class WeaponBuffBase: public WeaponTBase {
    public:
       WeaponBuffBase(WeaponPtr w): weapon{w}{};

       vector<DamageT> Damage() const override {
           return weapon->Damage();
       };

       int Cost() const override {
           return weapon->Cost();
       };

       string Name()  const override {
           return weapon->Name();
       };

       int Hit() const  override{
           return weapon->Hit();
       };
       int MaxDamage() const override {
           return weapon->MaxDamage();
       };

    protected:
       WeaponPtr weapon;
};


class HitWeaponBuff: public WeaponBuffBase {
    public:
       HitWeaponBuff(WeaponPtr w, int amt):WeaponBuffBase(w), buff{amt}{};

       int Hit() const override{
           return  weapon->Hit() + buff;
       }

       string Name() const override {
           return weapon->Name() + ", +" + to_string(buff) + " to hit";
       }

       int Cost() const override {
           return weapon->Cost() + 20*buff;
       }


    private:
       int buff;
    
};

class FireWeaponBuff: public WeaponBuffBase {
    public:
         FireWeaponBuff(WeaponPtr w, int amt):WeaponBuffBase(w), fire(amt){};

         vector<DamageT> Damage() const {
             vector<DamageT> rv;
             DamageT newDamage;

             rv = weapon->Damage();

             newDamage.type = DamageTypeT::FIRE;
             newDamage.amount = rand() % fire + 1;
             rv.push_back(newDamage);
             return rv;
         }

         string Name() const override {
             return weapon->Name() + ", +1d" + to_string(fire) + " fire damage";
         }
         
         int Cost() const override {
             return weapon->Cost() + 30*fire;
         }

         int MaxDamage() const override {
             return weapon->MaxDamage() + fire;
         }


    private:
       int fire;
};


void PrintWeapon(WeaponPtr weapon);

int main() {
    vector <WeaponPtr> weapons;
    WeaponPtr  weapon;

    weapon = make_shared<WeaponT>(1, 6, "Sword", DamageTypeT::PHYSICAL);
    weapons.push_back(weapon);

    weapon = make_shared<HitWeaponBuff>(weapon, 1);
    weapons.push_back(weapon);

    weapon = make_shared<FireWeaponBuff>(weapon, 10);
    weapons.push_back(weapon);

    for (auto w: weapons) {
       PrintWeapon(w);
    }

    
    return 0;
}

void PrintWeapon(WeaponPtr weapon){
    cout << "The weapon is a " << weapon-> Name() << endl;
    cout << "\tCost: " << weapon->Cost() << " gp" << endl;
    cout << "\tMaxDamage: " << weapon->MaxDamage() << endl;
    cout << "\tTo Hit: " << weapon->Hit() << endl;
    cout << "\tYou hit the target for: " << endl;
    for (auto & dmg: weapon->Damage()) {
       int pos = static_cast<int>(dmg.type);
       cout << "\t\t" << dmg.amount << " points of " 
            << DamageTypeName[pos] << endl;
    }
    cout << endl;
}