#include "Systems/Weapon/SidearmWeaponBehaviour.h"

void SidearmWeaponBehaviour::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt)
{
    Field<double> cooldown = cWeapon["FireCooldown"];
    if (cooldown > 0) {
        cooldown -= dt;
        if (cooldown < 0) {
            cooldown = 0;
        }
    }
    WeaponBehaviour::UpdateComponent(entity, cWeapon, dt);
}

void SidearmWeaponBehaviour::UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt)
{
    CheckAmmo(cWeapon, wi);

    // Start reloading automatically if at 0 mag ammo
    Field<int> magAmmo = cWeapon["MagazineAmmo"];
    if (m_ConfigAutoReload && magAmmo <= 0) {
        OnReload(cWeapon, wi);
    }

    // Only start reloading once we're done firing
    Field<bool> reloadQueued = cWeapon["ReloadQueued"];
    Field<double> fireCooldown = cWeapon["FireCooldown"];
    Field<bool> isReloading = cWeapon["IsReloading"];
    if (reloadQueued && fireCooldown <= 0) {
        reloadQueued = fireCooldown;
        isReloading = true;
    }

    // Decrement reload timer
    Field<double> reloadTimer = cWeapon["ReloadTimer"];
    if (isReloading) {
        reloadTimer = glm::max(0.0, reloadTimer - dt);
    }

    // Handle reloading
    if (isReloading && reloadTimer <= 0.0) {
        Field<int> magSize = cWeapon["MagazineSize"];

        magAmmo = magSize;
        isReloading = false;
        if (wi.FirstPersonEntity.Valid()) {
            wi.FirstPersonEntity.FirstChildByName("ViewModel")["Model"]["Visible"] = true;
        }
        if (wi.ThirdPersonEntity.Valid()) {
            wi.ThirdPersonEntity["Model"]["Visible"] = true;
        }
    }
    double reloadTime = cWeapon["ReloadTime"];
    if (isReloading && reloadTimer <= reloadTime / 2) {

    }

    // Update first person run animation
    ComponentWrapper cPlayer = wi.Player["Player"];
    ComponentWrapper cPhysics = wi.Player["Physics"];
    const float& movementSpeed = cPlayer["MovementSpeed"];
    float speed = glm::length((const glm::vec3&)cPhysics["Velocity"]);
    float animationWeight = glm::min(speed, movementSpeed) / movementSpeed;
    EntityWrapper rootNode = wi.FirstPersonEntity;
    if (rootNode.Valid()) {
        EntityWrapper blend = rootNode.FirstChildByName("MovementBlendSidearm");
        if (blend.Valid()) {
            (Field<double>)blend["Blend"]["Weight"] = animationWeight;
        }
    }

    // Restore view angle
    if (IsClient) {
        Field<float> currentTravel = cWeapon["CurrentTravel"];
        Field<float> returnSpeed = cWeapon["ViewReturnSpeed"];
        if (currentTravel > 0) {
            float change = returnSpeed * dt;
            currentTravel = glm::max(0.f, currentTravel - change);
            EntityWrapper camera = wi.Player.FirstChildByName("Camera");
            if (camera.Valid()) {
                Field<glm::vec3> cameraOrientation = camera["Transform"]["Orientation"];
                cameraOrientation.x(cameraOrientation.x() - change);
            }
        }
    }

    if ((bool)cWeapon["Automatic"] && canFire(cWeapon)) {
        fireBullet(cWeapon, wi);
    }
}

void SidearmWeaponBehaviour::OnPrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi)
{
    cWeapon["TriggerHeld"] = true;
    if (canFire(cWeapon)) {
        fireBullet(cWeapon, wi);
    }
}

void SidearmWeaponBehaviour::OnCeasePrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi)
{
    cWeapon["TriggerHeld"] = false;
}


void SidearmWeaponBehaviour::OnReload(ComponentWrapper cWeapon, WeaponInfo& wi)
{
    Field<bool> reloadQueued = cWeapon["ReloadQueued"];
    Field<bool> isReloading = cWeapon["IsReloading"];
    if (reloadQueued || isReloading) {
        return;
    }

    Field<int> magAmmo = cWeapon["MagazineAmmo"];
    Field<int> magSize = cWeapon["MagazineSize"];
    if (magAmmo >= magSize) {
        return;
    }

    double reloadTime = cWeapon["ReloadTime"];
    Field<double> reloadTimer = cWeapon["ReloadTimer"];

    // Start reload
    reloadQueued = true;
    reloadTimer = reloadTime;

    // Play animation
    playAnimationAndReturn(wi.FirstPersonEntity, "ActionBlend", "Reload");
    // Third person anim
    Events::AutoAnimationBlend eReloadBlend;
    eReloadBlend.RootNode = wi.ThirdPersonPlayerModel;
    eReloadBlend.NodeName = "Reload";
    eReloadBlend.Restart = true;
    eReloadBlend.Start = true;
    m_EventBroker->Publish(eReloadBlend);

    // Spawn explosion effect
    if (wi.FirstPersonEntity.Valid()) {
        if (IsClient) {
            EntityWrapper reloadEffectSpawner = wi.FirstPersonEntity.FirstChildByName("ReloadSpawner");
            if (reloadEffectSpawner.Valid()) {
                reloadEffectSpawner.DeleteChildren();
                SpawnerSystem::Spawn(reloadEffectSpawner, reloadEffectSpawner);
            }
        }
        wi.FirstPersonEntity.FirstChildByName("ViewModel")["Model"]["Visible"] = false;
    }
    if (wi.ThirdPersonEntity.Valid()) {
        if (IsServer) {
            EntityWrapper reloadEffectSpawner = wi.ThirdPersonEntity.FirstChildByName("ReloadSpawner");
            if (reloadEffectSpawner.Valid()) {
                reloadEffectSpawner.DeleteChildren();
                SpawnerSystem::Spawn(reloadEffectSpawner, reloadEffectSpawner);
            }
        }
        wi.ThirdPersonEntity["Model"]["Visible"] = false;
    }

    // Sound
    Events::PlaySoundOnEntity e;
    e.Emitter = wi.Player;
    e.FilePath = "Audio/weapon/Assault/AssaultWeaponReload.wav";
    m_EventBroker->Publish(e);
}

void SidearmWeaponBehaviour::OnEquip(ComponentWrapper cWeapon, WeaponInfo& wi)
{
    cWeapon["FireCooldown"] = (double)cWeapon["EquipTime"];

    if(wi.ThirdPersonPlayerModel.Valid()) {
        Events::AutoAnimationBlend b1;
        b1.RootNode = wi.ThirdPersonPlayerModel;
        b1.NodeName = "SidearmWeapon";
        b1.SingleLevelBlend = true;
        m_EventBroker->Publish(b1);
    }
}

void SidearmWeaponBehaviour::OnHolster(ComponentWrapper cWeapon, WeaponInfo& wi)
{
    // Make sure the trigger is released if weapon is holstered while firing
    cWeapon["TriggerHeld"] = false;

    // Cancel any reload
    cWeapon["IsReloading"] = false;
    cWeapon["ReloadTimer"] = 0.0;
}

void SidearmWeaponBehaviour::fireBullet(ComponentWrapper cWeapon, WeaponInfo& wi)
{
    cWeapon["FireCooldown"] = 60.0 / (double)cWeapon["RPM"];

    // Ammo
    Field<int> magAmmo = cWeapon["MagazineAmmo"];
    if (magAmmo <= 0) {
        return;
    } else {
        magAmmo -= 1;
    }

    // View punch
    if (IsClient) {
        EntityWrapper camera = wi.Player.FirstChildByName("Camera");
        if (camera.Valid()) {
            Field<glm::vec3> cameraOrientation = camera["Transform"]["Orientation"];
            float viewPunch = cWeapon["ViewPunch"];
            float maxTravelAngle = cWeapon["MaxTravelAngle"];
            Field<float> currentTravel = cWeapon["CurrentTravel"];
            if (currentTravel < maxTravelAngle) {
                float change = viewPunch;
                if (currentTravel + change > maxTravelAngle) {
                    change = maxTravelAngle - currentTravel;
                }
                cameraOrientation.x(cameraOrientation.x() + change);
                currentTravel += change;
            }
        }
    }

    // Get weapon model based on current person
    EntityWrapper weaponModelEntity = getRelevantWeaponEntity(wi);
    if (!weaponModelEntity.Valid()) {
        return;
    }

    // Tracer
    EntityWrapper tracerSpawner = weaponModelEntity.FirstChildByName("WeaponMuzzleRay");
    if (tracerSpawner.Valid()) {
        glm::vec3 origin = TransformSystem::AbsolutePosition(tracerSpawner);
        glm::vec3 direction = glm::quat(TransformSystem::AbsoluteOrientationEuler(tracerSpawner)) * glm::vec3(0, 0, -1);
        float distance = traceRayDistance(origin, direction);
        EntityWrapper ray = SpawnerSystem::Spawn(tracerSpawner, tracerSpawner);
        if (ray.Valid()) {
            ((Field<glm::vec3>)ray["Transform"]["Scale"]).x(distance);
            ((Field<glm::vec3>)ray["Transform"]["Position"]).z(-distance/2.f);
        }
    }

    //Flash
    EntityWrapper flashSpawner = weaponModelEntity.FirstChildByName("WeaponMuzzleFlash");
    if (flashSpawner.Valid()) {
        std::uniform_real_distribution<float> randomSpreadAngle(0.f, 3.1415f*2);
        EntityWrapper flash = SpawnerSystem::Spawn(flashSpawner, flashSpawner);
        if(flash.Valid()){
            ((Field<glm::vec3>)flash["Transform"]["Orientation"]).z(randomSpreadAngle(m_RandomEngine));
        }
    }


    // Deal damage
    if (dealDamage(cWeapon, wi)) {
        // Show hit marker
        EntityWrapper hitMarkerSpawner = wi.Player.FirstChildByName("HitMarkerSpawner");
        if (hitMarkerSpawner.Valid()) {
            SpawnerSystem::Spawn(hitMarkerSpawner, hitMarkerSpawner);
            Events::PlaySoundOnEntity e;
            e.Emitter = wi.Player;
            e.FilePath = "Audio/weapon/hitclick.wav";
            m_EventBroker->Publish(e);
        }
    }


    // Play animation
    playAnimationAndReturn(wi.FirstPersonEntity, "ActionBlend", "Fire");

    // Third person anim
    if (wi.ThirdPersonPlayerModel.Valid()) {
        Events::AutoAnimationBlend b1;
        b1.RootNode = wi.ThirdPersonPlayerModel;
        b1.NodeName = "Fire";
        b1.Restart = true;
        b1.Start = true;
        m_EventBroker->Publish(b1);
    }
}

bool SidearmWeaponBehaviour::canFire(ComponentWrapper cWeapon)
{
    bool triggerHeld = cWeapon["TriggerHeld"];
    bool cooldownPassed = (double)cWeapon["FireCooldown"] <= 0.0;
    bool isNotReloading = !(bool)cWeapon["IsReloading"];
    return triggerHeld && cooldownPassed && isNotReloading;
}

bool SidearmWeaponBehaviour::dealDamage(ComponentWrapper cWeapon, WeaponInfo& wi)
{
    // Only deal damage client side
    if (!IsClient) {
        return false;
    }

    // Only handle damage for the local player
    if (wi.Player != LocalPlayer) {
        return false;
    }

    // Make sure the player isn't shooting from the grave
    if (!wi.Player.Valid()) {
        return false;
    }

    // 3D-pick middle of screen
    Rectangle viewport = m_Renderer->GetViewportSize();
    glm::vec2 centerScreen(viewport.Width / 2, viewport.Height / 2);
    // TODO: Some horizontal spread
    PickData pickData = m_Renderer->Pick(centerScreen);
    EntityWrapper victim(m_World, pickData.Entity);
    if (!victim.Valid()) {
        return false;
    }

    // Don't let us somehow shoot ourselves in the foot
    if (victim == LocalPlayer) {
        return false;
    }

    // Only care about players being hit
    if (!victim.HasComponent("Player")) {
        victim = victim.FirstParentWithComponent("Player");
    }
    if (!victim.Valid()) {
        return false;
    }

    double damage = cWeapon["BaseDamage"];
    // If friendly fire, reduce damage to 0 (needed to make Boosts, Ammosharing work)
    if ((ComponentInfo::EnumType)victim["Team"]["Team"] == (ComponentInfo::EnumType)wi.Player["Team"]["Team"]) {
        damage = 0;

        bool gaveAmmo = false;

        if (victim.HasComponent("AssaultWeapon")) {
            int magazineSize = victim["AssaultWeapon"]["MagazineSize"];
            int magazineAmmo = victim["AssaultWeapon"]["MagazineAmmo"];

            int maxAmmo = victim["AssaultWeapon"]["MaxAmmo"];
            int ammo = victim["AssaultWeapon"]["Ammo"];

            if (magazineAmmo < magazineSize) {
                gaveAmmo = true;
            } else if (ammo < maxAmmo) {
                gaveAmmo = true;
            }
        } else if (victim.HasComponent("DefenderWeapon")) {
            int magazineSize = victim["DefenderWeapon"]["MagazineSize"];
            int magazineAmmo = victim["DefenderWeapon"]["MagazineAmmo"];

            int maxAmmo = victim["DefenderWeapon"]["MaxAmmo"];
            int ammo = victim["DefenderWeapon"]["Ammo"];

            if (magazineAmmo < magazineSize) {
                gaveAmmo = true;
            } else if (ammo < maxAmmo) {
                gaveAmmo = true;
            }
        }


        if (gaveAmmo) {
            EntityWrapper effectSpawner = wi.FirstPersonEntity.FirstChildByName("AmmoShareEffectSpawner");
            if (effectSpawner.Valid()) {
                if (effectSpawner.HasComponent("Spawner")) {
                    SpawnerSystem::Spawn(effectSpawner, effectSpawner);
                }
            }
        }
    }

    spawnTracer(cWeapon, wi);

    // Deal damage! 
    Events::PlayerDamage ePlayerDamage;
    ePlayerDamage.Inflictor = wi.Player;
    ePlayerDamage.Victim = victim;
    ePlayerDamage.Damage = damage;
    m_EventBroker->Publish(ePlayerDamage);

    return damage > 0;
}

void SidearmWeaponBehaviour::spawnTracer(ComponentWrapper cWeapon, WeaponInfo& wi)
{
    EntityWrapper muzzle = getRelevantWeaponEntity(wi).FirstChildByName("WeaponMuzzle");
    if (!muzzle.Valid()) {
        return;
    }

    EntityWrapper camera = wi.Player.FirstChildByName("Camera");
    if (!camera.Valid()) {
        return;
    }

    glm::vec3 cameraPosition = TransformSystem::AbsolutePosition(camera);
    glm::vec3 direction = glm::vec3(0, 0, -1);

    float distance;
    glm::vec3 hitPosition;
    Collision::EntityFirstHitByRay(Ray(cameraPosition, direction), m_CollisionOctree, distance, hitPosition);

    EntityWrapper ray = SpawnerSystem::Spawn(muzzle);
    if (ray.Valid()) {
        ComponentWrapper cTransform = ray["Transform"];
        Field<glm::vec3> rayOrigin = cTransform["Position"];
        Field<glm::vec3> rayOrientation = cTransform["Orientation"];
        Field<glm::vec3> rayScale = cTransform["Scale"];

        glm::vec3 muzzlePosition = TransformSystem::AbsolutePosition(muzzle);
        glm::quat muzzleOrientation = TransformSystem::AbsoluteOrientation(muzzle);

        rayOrigin = muzzlePosition;

        glm::vec3 muzzleToHit = hitPosition - muzzlePosition;
        glm::vec3 lookVector = glm::normalize(-muzzleToHit);
        float pitch = std::asin(-lookVector.y);
        float yaw = std::atan2(lookVector.x, lookVector.z);
        glm::quat orientation = glm::quat(glm::vec3(pitch, yaw, 0));
        rayOrientation = glm::eulerAngles(orientation);
        rayScale.z(glm::length(muzzleToHit));
    }

}

/*

void SidearmWeaponBehaviour::giveAmmo(ComponentWrapper cWeapon, WeaponInfo& wi, EntityWrapper receiver)
{
    bool gaveAmmo = false;

    if (receiver.HasComponent("AssaultWeapon")) {
        int magazineSize = receiver["AssaultWeapon"]["MagazineSize"];
        int& magazineAmmo = receiver["AssaultWeapon"]["MagazineAmmo"];

        int maxAmmo = receiver["AssaultWeapon"]["MaxAmmo"]; 
        int& ammo = receiver["AssaultWeapon"]["Ammo"];

        if(magazineAmmo < magazineSize) {
            magazineAmmo += 1;
            gaveAmmo = true;
        } else if (ammo < maxAmmo) {
            ammo += 1;
            gaveAmmo = true;
        }
    } else if (receiver.HasComponent("DefenderWeapon")) {
        int magazineSize = receiver["DefenderWeapon"]["MagazineSize"];
        int& magazineAmmo = receiver["DefenderWeapon"]["MagazineAmmo"];

        int maxAmmo = receiver["DefenderWeapon"]["MaxAmmo"];
        int& ammo = receiver["DefenderWeapon"]["Ammo"];

        if (magazineAmmo < magazineSize) {
            magazineAmmo += 1;
            gaveAmmo = true;
        } else if (ammo < maxAmmo) {
            ammo += 1;
            gaveAmmo = true;
        }
    }


    if(gaveAmmo) {
        EntityWrapper effectSpawner = wi.FirstPersonEntity.FirstChildByName("AmmoShareEffectSpawner");
        if(effectSpawner.Valid()) {
            if (effectSpawner.HasComponent("Spawner")) {
                SpawnerSystem::Spawn(effectSpawner, effectSpawner);
            }
        }
    }
}*/

void SidearmWeaponBehaviour::CheckAmmo(ComponentWrapper cWeapon, WeaponInfo& wi)
{
    // Only check ammo client side
    if (!IsClient) {
        return;
    }

    // Only handle ammo check for the local player
    if (wi.Player != LocalPlayer) {
        return;
    }

    // Make sure the player isn't checking from the grave
    if (!wi.Player.Valid()) {
        return;
    }

    // 3D-pick middle of screen
    Rectangle viewport = m_Renderer->GetViewportSize();
    glm::vec2 centerScreen(viewport.Width / 2, viewport.Height / 2);
    // TODO: Some horizontal spread
    PickData pickData = m_Renderer->Pick(centerScreen);
    EntityWrapper victim(m_World, pickData.Entity);
    if (!victim.Valid()) {
        RemoveFrindlyAmmoHUD(wi);
        return;
    }

    // Don't let us somehow shoot ourselves in the foot
    if (victim == LocalPlayer) {
        RemoveFrindlyAmmoHUD(wi);
        return;
    }

    // Only care about players being hit
    if (!victim.HasComponent("Player")) {
        victim = victim.FirstParentWithComponent("Player");
    }
    if (!victim.Valid()) {
        RemoveFrindlyAmmoHUD(wi);
        return;
    }


    // If friendly fire, reduce damage to 0 (needed to make Boosts, Ammosharing work)
    if ((ComponentInfo::EnumType)victim["Team"]["Team"] == (ComponentInfo::EnumType)wi.Player["Team"]["Team"]) {
        int magazineAmmo = 0;
        int ammo = 0;
        if (victim.HasComponent("AssaultWeapon")) {
            magazineAmmo = (int)victim["AssaultWeapon"]["MagazineAmmo"];
            ammo = (int)victim["AssaultWeapon"]["Ammo"];

        } else if (victim.HasComponent("DefenderWeapon")) {
            magazineAmmo = (int)victim["DefenderWeapon"]["MagazineAmmo"];
            ammo = (int)victim["DefenderWeapon"]["Ammo"];
        }


        EntityWrapper friendlyAmmoHudSpawner = wi.FirstPersonPlayerModel.FirstChildByName("FriendlyAmmoAttachment");
        if (friendlyAmmoHudSpawner.Valid()) {

            auto children = m_World->GetDirectChildren(friendlyAmmoHudSpawner.ID);

            if (children.first == children.second) {
                if (friendlyAmmoHudSpawner.HasComponent("Spawner")) {
                    EntityWrapper friendlyAmmoHud = SpawnerSystem::Spawn(friendlyAmmoHudSpawner, friendlyAmmoHudSpawner);
                    if (friendlyAmmoHud.Valid()) {
                        EntityWrapper textEntity = friendlyAmmoHud.FirstChildByName("MagazineAmmo");
                        if (textEntity.Valid()) {
                            if (textEntity.HasComponent("Text")) {
                                (Field<std::string>)textEntity["Text"]["Content"] = std::to_string(magazineAmmo);
                            }
                        }

                        EntityWrapper ammoTextEntity = friendlyAmmoHud.FirstChildByName("Ammo");
                        if (ammoTextEntity.Valid()) {
                            if (ammoTextEntity.HasComponent("Text")) {
                                (Field<std::string>)ammoTextEntity["Text"]["Content"] = std::to_string(ammo);
                            }
                        }
                    }
                }
            } else {
                EntityWrapper textEntity = friendlyAmmoHudSpawner.FirstChildByName("MagazineAmmo");
                if (textEntity.Valid()) {
                    if (textEntity.HasComponent("Text")) {
                        (Field<std::string>)textEntity["Text"]["Content"] = std::to_string(magazineAmmo);
                    }
                }

                EntityWrapper ammoTextEntity = friendlyAmmoHudSpawner.FirstChildByName("Ammo");
                if (ammoTextEntity.Valid()) {
                    if (ammoTextEntity.HasComponent("Text")) {
                        (Field<std::string>)ammoTextEntity["Text"]["Content"] = std::to_string(ammo);
                    }
                }
            }
        }
    }
}

void SidearmWeaponBehaviour::RemoveFrindlyAmmoHUD(WeaponInfo& wi)
{
    EntityWrapper friendlyAmmoHudSpawner = wi.FirstPersonPlayerModel.FirstChildByName("FriendlyAmmoAttachment");
    if (friendlyAmmoHudSpawner.Valid()) {
        friendlyAmmoHudSpawner.DeleteChildren();
    }
}