#include <algorithm>

#include "destroyer.h"
#include "destroyerData.h"
#include "defConfigs.h"
#include "depthCharge.h"
#include "inGameAppState.h"
#include "stateManager.h"
#include "projectileData.h"
#include "util.h"

using namespace std;
using namespace vb01;
using namespace game::core;
using namespace game::util;
using namespace game::content::unitData;

namespace game{
    namespace content{
        Destroyer::Destroyer(Player *player, vb01::Vector3 pos,int id) : Vessel(player, pos, id) {
            this->maxDepthCharges = unitData::maxDepthCharges[id];
            depthCharges = maxDepthCharges;
            this->rateOfDrops = unitData::rateOfDrops[id];
            this->reloadRate = unitData::reloadRate[id];
            this->maxDepthChargeDropRange = unitData::maxDepthChargeDropRange[id];
        }

        void Destroyer::update(){
            Vessel::update();
            reload();
        }

        void Destroyer::attack(Order order){
            Vector3 t = *order.targetPos[0];
            bool sub=false;
            InGameAppState *inGameState=((InGameAppState*)GameManager::getSingleton()->getStateManager()->getAppState(AppStateTypes::IN_GAME_STATE));

            for(Player *p : inGameState->getPlayers())
                for(Unit *u : p->getUnits())
                    if(u->getType() == UNIT_TYPE::SUBMARINE&&order.targetPos[0] == u->getPosPtr())
                        sub = true;

            if(sub)
                dropDepthCharge();
            else 
                Vessel::attack(order);
        }

        void Destroyer::dropDepthCharge() {
            if(canDropDepthCharge()){
                float angle = rand() % 360;
                float radius = 1;
                Vector3 offsetVec = Vector3(cos(angle), 0, sin(angle)) * radius;
                addProjectile(new DepthCharge(this, pos + projectileData::pos[id][1][1] + offsetVec, dirVec, leftVec, upVec, id, 1, 0));
                lastDropTime = getTime();

                if(depthCharges == maxDepthCharges)
                    reloadStartTime = getTime();
                
            }
        }
        void Destroyer::reload(){
            if(depthCharges < maxDepthCharges){
                reloading = true;

                if(getTime() - reloadStartTime > reloadRate) {
                    reloadStartTime += reloadRate;
                    depthCharges++;
                }
            }
            else
                reloading = false;
        }
    }
}