#include "Systems/Weapon/DefenderWeaponBehaviour.h"

void DefenderWeaponBehaviour::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt)
{
    double& fireCooldown = cWeapon["FireCooldown"];
    fireCooldown = glm::max(0.0, fireCooldown - dt);

    WeaponBehaviour::UpdateComponent(entity, cWeapon, dt);
}

void DefenderWeaponBehaviour::UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt)
{
    // Decrement reload timer
    double& reloadTimer = cWeapon["ReloadTimer"];
    reloadTimer = glm::max(0.0, reloadTimer - dt);

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

    // Handle reloading
    bool& isReloading = cWeapon["IsReloading"];
    if (isReloading && reloadTimer <= 0.0) {
        double reloadTime = cWeapon["ReloadTime"];
        int& magSize = cWeapon["MagazineSize"];
        int& ammo = cWeapon["Ammo"];
        if (magAmmo < magSize && ammo > 0) {
            ammo -= 1;
            magAmmo += 1;
            reloadTimer = reloadTime;
            Events::PlaySoundOnEntity e;
            e.EmitterID = wi.Player.ID;
            e.FilePath = "Audio/weapon/Zoom.wav";
            m_EventBroker->Publish(e);
        } else {
            isReloading = false;
            playAnimationAndReturn(wi.FirstPersonEntity, "FinalBlend", "ReloadEnd");

            if (wi.ThirdPersonPlayerModel.Valid()) {
                Events::AutoAnimationBlend eFireIdle;
                eFireIdle.Duration = 0.2;
                eFireIdle.RootNode = wi.ThirdPersonPlayerModel;
                eFireIdle.NodeName = "Fire";
                eFireIdle.Start = false;
                m_EventBroker->Publish(eFireIdle);
            }

        }
    }

    // Restore view angle
    if (IsClient) {
        float& currentTravel = cWeapon["CurrentTravel"];
        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()) {
                glm::vec3& cameraOrientation = camera["Transform"]["Orientation"];
                cameraOrientation.x -= change;
            }
        }
    }

    // Fire if we're able to fire
    if (canFire(cWeapon, wi)) {
        fireShell(cWeapon, wi);
    }
}

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

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

void DefenderWeaponBehaviour::OnReload(ComponentWrapper cWeapon, WeaponInfo& wi)
{
    bool& isReloading = cWeapon["IsReloading"];
    if (isReloading) {
        return;
    }

    int& magAmmo = cWeapon["MagazineAmmo"];
    int& magSize = cWeapon["MagazineSize"];
    if (magAmmo >= magSize) {
        return;
    }
    int& ammo = cWeapon["Ammo"];
    if (ammo <= 0) {
        return;
    }

    double reloadTime = cWeapon["ReloadTime"];
    double& reloadTimer = cWeapon["ReloadTimer"];
   
    // Start reload
    isReloading = true;
    reloadTimer = reloadTime;

    // Play animation
    if (wi.FirstPersonEntity.Valid()) {
        Events::AutoAnimationBlend eBlendStart;
        eBlendStart.RootNode = wi.FirstPersonEntity;
        eBlendStart.NodeName = "ReloadStart";
        eBlendStart.Restart = true;
        eBlendStart.Start = true;
        m_EventBroker->Publish(eBlendStart);
        Events::AutoAnimationBlend eBlendLoop;
        eBlendLoop.RootNode = wi.FirstPersonEntity;
        eBlendLoop.NodeName = "ReloadLoop";
        eBlendLoop.Restart = true;
        eBlendLoop.Start = true;
        eBlendLoop.AnimationEntity = wi.FirstPersonEntity.FirstChildByName("ReloadStart");
        m_EventBroker->Publish(eBlendLoop);
    }

    if(wi.ThirdPersonPlayerModel.Valid()) {
        Events::AutoAnimationBlend eReload;
        eReload.Duration = 0.2;
        eReload.RootNode = wi.ThirdPersonPlayerModel;
        eReload.NodeName = "Reload";
        eReload.Restart = true;
        eReload.Start = true;
        m_EventBroker->Publish(eReload);
    }
}

void DefenderWeaponBehaviour::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;
}

bool DefenderWeaponBehaviour::OnInputCommand(ComponentWrapper cWeapon, WeaponInfo& wi, const Events::InputCommand& e)
{
    if (e.Command == "SpecialAbility") {
        EntityWrapper attachment = wi.Player.FirstChildByName("ShieldAttachment");
        if (attachment.Valid()) {
            if (e.Value > 0) {

                if(wi.Player.Valid()) {
                    if(wi.Player.HasComponent("ShieldAbility")) {
                        (bool&)wi.Player["ShieldAbility"]["Active"] = true;
                    }
                }

                if (IsServer) {
                    SpawnerSystem::Spawn(attachment, attachment);
                }

                EntityWrapper backAttachment = attachment.FirstChildByName("Back");
                if (backAttachment.Valid()) {
                    Events::AutoAnimationBlend eDeployShieldAttachement;
                    eDeployShieldAttachement.RootNode = backAttachment;
                    eDeployShieldAttachement.NodeName = "Deploy";
                    eDeployShieldAttachement.Restart = true;
                    eDeployShieldAttachement.Start = true;
                    m_EventBroker->Publish(eDeployShieldAttachement);
                }
                EntityWrapper frontAttachment = attachment.FirstChildByName("Front");
                if (frontAttachment.Valid()) {
                    Events::AutoAnimationBlend eDeployShieldAttachement;
                    eDeployShieldAttachement.RootNode = frontAttachment;
                    eDeployShieldAttachement.NodeName = "Deploy";
                    eDeployShieldAttachement.Restart = true;
                    eDeployShieldAttachement.Start = true;
                    m_EventBroker->Publish(eDeployShieldAttachement);

                }

                if (IsClient) {
                    EntityWrapper root = wi.FirstPersonEntity;
                    if (root.Valid()) {
                        EntityWrapper animationNode = root.FirstChildByName("Shield");
                        if (animationNode.Valid()) {
                            Events::AutoAnimationBlend eShieldBlend;
                            eShieldBlend.RootNode = root;
                            eShieldBlend.NodeName = "Shield";
                            eShieldBlend.Restart = true;
                            eShieldBlend.Start = true;
                            m_EventBroker->Publish(eShieldBlend);
                        }
                    }
                } else { // server only
                    EntityWrapper root = wi.ThirdPersonPlayerModel;
                    if (root.Valid()) {
                        Events::AutoAnimationBlend eShieldActivateBlend;
                        eShieldActivateBlend.RootNode = root;
                        eShieldActivateBlend.NodeName = "ActivateShield";
                        eShieldActivateBlend.Restart = true;
                        eShieldActivateBlend.Start = true;
                        m_EventBroker->Publish(eShieldActivateBlend);

                        EntityWrapper animationNode = root.FirstChildByName("ActivateShield");
                        if (animationNode.Valid()) {
                            Events::AutoAnimationBlend eShieldIdleBlend;
                            eShieldIdleBlend.RootNode = root;
                            eShieldIdleBlend.NodeName = "ShieldFront";
                            eShieldIdleBlend.Restart = true;
                            eShieldIdleBlend.Start = true;
                            eShieldIdleBlend.AnimationEntity = animationNode;
                            m_EventBroker->Publish(eShieldIdleBlend);
                        }
                    }
                }
            } else {
                attachment.DeleteChildren();

                if (wi.Player.Valid()) {
                    if (wi.Player.HasComponent("ShieldAbility")) {
                        (bool&)wi.Player["ShieldAbility"]["Active"] = false;
                    }
                }

                if (IsClient) {
                    EntityWrapper root = wi.FirstPersonEntity;
                    if (root.Valid()) {
                        EntityWrapper animationNode = root.FirstChildByName("ActionBlend");
                        if (animationNode.Valid()) {
                            Events::AutoAnimationBlend eFireBlend;
                            eFireBlend.RootNode = root;
                            eFireBlend.NodeName = "ActionBlend";
                            eFireBlend.Restart = true;
                            eFireBlend.Start = true;
                            m_EventBroker->Publish(eFireBlend);
                        }
                    }
                } else { // server only
                    EntityWrapper root = wi.ThirdPersonPlayerModel;
                    if (root.Valid()) {
                        Events::AutoAnimationBlend eShieldDeactivateBlend;
                        eShieldDeactivateBlend.RootNode = root;
                        eShieldDeactivateBlend.NodeName = "ActivateShield";
                        eShieldDeactivateBlend.Restart = true;
                        eShieldDeactivateBlend.Start = true;
                        eShieldDeactivateBlend.Reverse = true;
                        m_EventBroker->Publish(eShieldDeactivateBlend);

                        EntityWrapper animationNode = root.FirstChildByName("ActivateShield");
                        if (animationNode.Valid()) {
                            Events::AutoAnimationBlend eActionBlend;
                            eActionBlend.RootNode = root;
                            eActionBlend.NodeName = "ActionBlend";
                            eActionBlend.AnimationEntity = animationNode;
                            m_EventBroker->Publish(eActionBlend);
                        }
                    }
                }
            }
        }
    }

    return false;
}


void DefenderWeaponBehaviour::OnEquip(ComponentWrapper cWeapon, WeaponInfo& wi)
{
    if (wi.ThirdPersonPlayerModel.Valid()) {
        Events::AutoAnimationBlend b1;
        b1.RootNode = wi.ThirdPersonPlayerModel;
        b1.NodeName = "DefenderWeapon";
        b1.SingleLevelBlend = true;
        m_EventBroker->Publish(b1);
    }
}

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

    // Stop reloading
    bool& isReloading = cWeapon["IsReloading"];
    isReloading = false;

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

    // We can't really do any valuable calculations without a valid camera
    if (!m_CurrentCamera.Valid()) {
        return;
    }

    int numPellets = cWeapon["NumPellets"];

    // Create a spread pattern
    std::vector<glm::vec2> pattern;
    // The first pellet is always centered
    pattern.push_back(glm::vec2(0, 0));
    // Any additional pellets form circles around the middle
    int numOuterPellets = numPellets - 1;
    float angleIncrement = glm::two_pi<float>() / numOuterPellets;
    for (int i = 0; i < numOuterPellets; ++i) {
        float angle = angleIncrement * i;
        glm::vec2 pellet = glm::vec2(glm::cos(angle), glm::sin(angle));
        pattern.push_back(pellet);
    }

    // Deal damage (clientside)
    dealDamage(cWeapon, wi, pattern);

    // Spawn tracers
    spawnTracers(cWeapon, wi, pattern);

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

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

    // Sound
    Events::PlaySoundOnEntity e;
    e.EmitterID = wi.Player.ID;
    e.FilePath = "Audio/weapon/Blast.wav";
    m_EventBroker->Publish(e);
}

void DefenderWeaponBehaviour::spawnTracers(ComponentWrapper cWeapon, WeaponInfo& wi, std::vector<glm::vec2> pattern)
{
    EntityWrapper muzzle = getRelevantWeaponEntity(wi).FirstChildByName("WeaponMuzzle");
    if (!muzzle.Valid()) {
        return;
    }

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

    float spreadAngle = glm::radians((float)cWeapon["SpreadAngle"]);

    for (auto& pellet : pattern) {
        glm::quat pelletRotation = glm::quat(Transform::AbsoluteOrientationEuler(camera)) * glm::quat(glm::vec3(pellet.y, pellet.x, 0) * spreadAngle);
        glm::vec3 cameraPosition = Transform::AbsolutePosition(camera);
        glm::vec3 direction = pelletRotation * 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"];
            glm::vec3& rayOrigin = cTransform["Position"];
            glm::vec3& rayOrientation = cTransform["Orientation"];
            glm::vec3& rayScale = cTransform["Scale"];

            glm::vec3 muzzlePosition = Transform::AbsolutePosition(muzzle);
            glm::quat muzzleOrientation = Transform::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 DefenderWeaponBehaviour::dealDamage(ComponentWrapper cWeapon, WeaponInfo& wi, const std::vector<glm::vec2>& pattern)
{
    // Only deal damage client side
    if (!IsClient) {
        return;
    }

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

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

    // Convert the spread angle to screen coordinates, taking FOV into account
    Rectangle res = m_Renderer->GetViewportSize();
    float spreadAngle = glm::radians((float)cWeapon["SpreadAngle"]);
    float nearClip = (double)m_CurrentCamera["Camera"]["NearClip"];
    float farClip = (double)m_CurrentCamera["Camera"]["FarClip"];
    float yFOV = glm::radians((double)m_CurrentCamera["Camera"]["FOV"]);
    //float yRefFOV = glm::radians(59.f);
    //float yRef = glm::tan(yRefFOV) * nearClip;
    //float yRatio = yRef / (glm::tan(yFOV) * nearClip);
    //float yMax = (yRatio / 2.f) * spreadAngle * (res.Height / 2.f);
    float yRefFOV = glm::radians(59.f);
    float yRef = glm::tan(yRefFOV) * nearClip;
    float yRatio = yRef / (glm::tan(yFOV) * nearClip);
    float yMax = yRatio * (glm::tan(spreadAngle) * (farClip - nearClip)) * glm::pi<float>(); // ????? Good enough????

    LOG_DEBUG("Ratio: %f", yRatio);
    LOG_DEBUG("fatClip: %f", farClip);
    LOG_DEBUG("yMax: %f", yMax);
    double pelletDamage = (double)cWeapon["BaseDamage"] / pattern.size();

    // Pick!
    std::unordered_map<EntityWrapper, double> damageSum;
    glm::vec2 screenCenter(res.Width / 2.f, res.Height / 2.f);
    for (auto& pellet : pattern) {
        glm::vec2 pickCoord = screenCenter + (pellet * glm::vec2(yMax, yMax));
        PickData pick = m_Renderer->Pick(pickCoord);        

        EntityWrapper victim(m_World, pick.Entity);
        if (!victim.Valid()) {
            continue;
        }

        // Temp hit decal
        EntityWrapper hit = ResourceManager::Load<EntityFile>("Schema/Entities/HitTest.xml")->MergeInto(m_World);
        hit["Transform"]["Position"] = pick.Position;

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

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

        // Check for friendly fire
        if ((ComponentInfo::EnumType)victim["Team"]["Team"] == (ComponentInfo::EnumType)wi.Player["Team"]["Team"]) {
            // TODO: Ammo sharing
            continue;
        }

        damageSum[victim] += pelletDamage;
        ((glm::vec3&)hit["Model"]["Color"]).b = 1.f;
    }

    // Deal damage!
    for (auto& kv : damageSum) {
        // Deal damage! 
        Events::PlayerDamage ePlayerDamage;
        ePlayerDamage.Inflictor = wi.Player;
        ePlayerDamage.Victim = kv.first;
        ePlayerDamage.Damage = kv.second;
        m_EventBroker->Publish(ePlayerDamage);
        LOG_DEBUG("Dealt %f damage to #%i", kv.second, kv.first.ID);
    }
}

bool DefenderWeaponBehaviour::canFire(ComponentWrapper cWeapon, WeaponInfo& wi)
{
    bool triggerHeld = cWeapon["TriggerHeld"];
    bool cooldownPassed = (double)cWeapon["FireCooldown"] <= 0.0;
    bool isNotShielding = wi.Player.ChildrenWithComponent("Shield").size() == 0;
    return triggerHeld && cooldownPassed && isNotShielding;
}

Camera DefenderWeaponBehaviour::cameraFromEntity(EntityWrapper camera)
{
    ComponentWrapper cTransform = camera["Transform"];
    ComponentWrapper cCamera = camera["Camera"];
    Camera cam(
        (float)m_Renderer->Resolution().Width / m_Renderer->Resolution().Height, 
        (double)cCamera["FOV"], 
        (double)cCamera["NearClip"], 
        (double)cCamera["FarClip"]
    );
    cam.SetPosition(cTransform["Position"]);
    cam.SetOrientation(glm::quat((const glm::vec3&)cTransform["Orientation"]));
    return cam;
}