/*
 * Copyright (C) Volition, Inc. 1999.  All rights reserved.
 *
 * All source code herein is the property of Volition, Inc. You may not sell 
 * or otherwise commercially exploit the source or things you created based on the 
 * source.
 */ 



#include "math/staticrand.h"
#include "network/multi.h"
#include "object/object.h"
#include "object/objectshield.h"
#include "ship/ship.h"
#include "ship/subsysdamage.h"

#include <limits.h>


float shield_get_strength(object *objp)
{
	// no shield system, no strength!
	if (objp->flags[Object::Object_Flags::No_shields])
		return 0.0f;

	int	i;
	float strength = 0.0f;

	for (i = 0; i < objp->n_quadrants; i++)
		strength += shield_get_quad(objp, i);

	return strength;
}

void shield_set_strength(object *objp, float strength)
{
	int	i;

	for (i = 0; i < objp->n_quadrants; i++)
		shield_set_quad(objp, i, strength / objp->n_quadrants);
}

//	Recharge whole shield.
//	Apply delta/n_quadrants to each shield section.
void shield_add_strength(object *objp, float delta)
{
	// if we aren't going to change anything anyway then just bail
	if (delta == 0.0f)
		return;

	float shield_str = shield_get_strength(objp);
	float shield_recharge_limit = shield_get_max_strength(objp);

	if (shield_str >= shield_recharge_limit)
		return;

	if (!(Ai_info[Ships[objp->instance].ai_index].ai_profile_flags[AI::Profile_Flags::Smart_shield_management])
		|| delta <= 0.0f) //SUSHI: We don't want smart shield management for negative delta
	{
		// set the limit for the shield recharge
		if ((delta > 0.0f) && ((shield_str + delta) > shield_recharge_limit))
			delta = shield_recharge_limit - shield_str;

		for (int i = 0; i < objp->n_quadrants; i++)
			shield_add_quad(objp, i, delta / objp->n_quadrants);
	}
	else
	{
		float section_max = shield_get_max_quad(objp);

		// smart shield repair
		while (delta > 0.0f)
		{
			//WMC - Set to INT_MAX so that this is set to something
			float weakest = i2fl(INT_MAX);
			int weakest_idx = -1;

			// find weakest shield quadrant
			for (int i = 0; i < objp->n_quadrants; i++)
			{
				float quad = shield_get_quad(objp, i);
				if (weakest_idx < 0 || quad < weakest)
				{
					weakest = quad;
					weakest_idx = i;
				}
			}

			// all quads are at full strength
			if (weakest >= section_max)
				break;

			// set the limit for the shield recharge
			if ((delta > 0.0f) && ((shield_str + delta) > shield_recharge_limit))
				delta = shield_recharge_limit - shield_str;

			// throw all possible shield power at this quadrant
			// if there's any left over then apply it to the next weakest on the next pass
			float xfer_amount;
			if (weakest + delta > section_max)
				xfer_amount = section_max - weakest;
			else
				xfer_amount = delta;

			shield_add_quad(objp, weakest_idx, xfer_amount);
			delta -= xfer_amount;
		}
	}
}

static double factor = 1.0 / (log(50.0) - log(1.0));

// Goober5000
float scale_quad(float generator_fraction, float quad_strength)
{
	// the following formula makes a nice logarithmic curve between 1 and 50,
	// when x goes from 0 to 100:
	//
	// ln(x) * (100 - 0)
	// -----------------
	//  ln(50) - ln(1)
	//
	float effective_strength = quad_strength * ((float)log(generator_fraction) * (float)factor);

	// ensure not negative, which may happen if the shield gets below 1 percent
	// (since we're dealing with logs)
	if (effective_strength < 0.0f)
		return 0.0f;
	else
		return effective_strength;
}

// Goober5000
float shield_get_quad(object *objp, int quadrant_num)
{
	// no shield system, no strength!
	if (objp->flags[Object::Object_Flags::No_shields])
		return 0.0f;

	// check array bounds
	Assert(quadrant_num >= 0 && quadrant_num < objp->n_quadrants);
	if (quadrant_num < 0 || quadrant_num >= objp->n_quadrants)
		return 0.0f;

	if (objp->type != OBJ_SHIP && objp->type != OBJ_START)
		return 0.0f;

	//WMC -	I removed SUBSYSTEM_SHIELD_GENERATOR to prevent pilot file
	//		corruption, so comment all this out...
	/*
	// yarr!
	ship_subsys_info *ssip = &Ships[objp->instance].subsys_info[SUBSYSTEM_SHIELD_GENERATOR];

	// do we have a shield generator?
	if (ssip->num > 0 && !Fred_running)
	{
		// rules for shield generator affecting coverage:
		//	1. if generator above 50%, effective strength = actual strength
		//	2. if generator below 50%, effective strength uses the scale_quad formula
		//	3. if generator below 30%, shields only have a sqrt(generator strength)
		//		chance of working, in addition to #2
		float generator_fraction = ssip->current_hits / ssip->total_hits;

		if (generator_fraction > MIN_SHIELDS_FOR_FULL_STRENGTH)
		{
			return objp->shield_quadrant[quadrant_num];
		}
		else if (generator_fraction > MIN_SHIELDS_FOR_FULL_COVERAGE)
		{
			return scale_quad(generator_fraction, objp->shield_quadrant[quadrant_num]);
		}
		else
		{
			// randomize according to this object and the current time
			// (Missiontime >> 13 is eighths of a second) 
			float rand_num = static_randf(OBJ_INDEX(objp) ^ (Missiontime >> 13));

			// maybe flicker the shield
			if (rand_num < sqrt(generator_fraction))
				return scale_quad(generator_fraction, objp->shield_quadrant[quadrant_num]);
			else
				return 0.0f;
		}
	}
	// no shield generator, so behave as normal
	else
	*/
		return objp->shield_quadrant[quadrant_num];
}

// Goober5000
void shield_set_quad(object *objp, int quadrant_num, float strength)
{
	// check array bounds
	Assert(quadrant_num >= 0 && quadrant_num < objp->n_quadrants);
	if (quadrant_num < 0 || quadrant_num >= objp->n_quadrants)
		return;

	// check range
	if (strength < 0.0f)
		strength = 0.0f;
	float max_quad = shield_get_max_quad(objp);
	if (strength > max_quad)
		strength = max_quad;

	objp->shield_quadrant[quadrant_num] = strength;
}

// Goober5000
void shield_add_quad(object *objp, int quadrant_num, float delta)
{
	// if we aren't going to change anything anyway then just bail
	if (delta == 0.0f)
		return;

	// check array bounds
	Assert(quadrant_num >= 0 && quadrant_num < objp->n_quadrants);
	if (quadrant_num < 0 || quadrant_num >= objp->n_quadrants)
		return;

	// important: don't use shield_get_quad here
	float strength = objp->shield_quadrant[quadrant_num] + delta;

	// check range
	if (strength < 0.0f)
		strength = 0.0f;
	float max_quad = shield_get_max_quad(objp);
	if (strength > max_quad)
		strength = max_quad;

	objp->shield_quadrant[quadrant_num] = strength;
}

// Goober5000
// @Note $Max Shield Recharge is not intended to affect max strength of individual shield segments
float shield_get_max_strength(object *objp, bool no_msr)
{
	Assertion(objp != nullptr, "nullptr passed to shield_get_max_strength, get a coder!");
	if (objp->type != OBJ_SHIP && objp->type != OBJ_START)
		return 0.0f;

	if (no_msr == true)
		return Ships[objp->instance].ship_max_shield_strength;
	else
		return Ships[objp->instance].ship_max_shield_strength * Ships[objp->instance].max_shield_recharge;
}

void shield_set_max_strength(object *objp, float newmax)
{
	if(objp->type != OBJ_SHIP)
		return;

	Ships[objp->instance].ship_max_shield_strength = newmax;
}

// Goober5000
float shield_get_max_quad(object *objp)
{
	return shield_get_max_strength(objp, true) / objp->n_quadrants;
}

//	***** This is the version that works on a quadrant basis.
//	Return absolute amount of damage not applied.
float shield_apply_damage(object *objp, int quadrant_num, float damage)
{
	float remaining_damage;

	// multiplayer clients bail here if nodamage
	// if(MULTIPLAYER_CLIENT && (Netgame.debug_flags & NETD_FLAG_CLIENT_NODAMAGE)){
	if (MULTIPLAYER_CLIENT)
		return damage;

	// check array bounds
	Assert(quadrant_num >= 0 && quadrant_num < objp->n_quadrants);
	if ((quadrant_num < 0) || (quadrant_num >= objp->n_quadrants))
		return damage;	
	
	if (objp->type != OBJ_SHIP && objp->type != OBJ_START)
		return damage;

	Ai_info[Ships[objp->instance].ai_index].last_hit_quadrant = quadrant_num;

	remaining_damage = damage - shield_get_quad(objp, quadrant_num);
	if (remaining_damage > 0.0f)
	{
		shield_set_quad(objp, quadrant_num, 0.0f);
		return remaining_damage;
	}
	else
	{
		shield_add_quad(objp, quadrant_num, -damage);
		return 0.0f;
	}
}

// Returns true if the shield presents any opposition to something 
// trying to force through it.
// If quadrant is -1, looks at entire shield, otherwise
// just one quadrant
int shield_is_up(object *objp, int quadrant_num)
{
	if ((quadrant_num >= 0) && (quadrant_num < objp->n_quadrants))
	{
		// Just check one quadrant
		float quad = shield_get_quad(objp, quadrant_num);

		if (quad > MAX(2.0f, 0.1f * shield_get_max_quad(objp)))
			return 1;
	}
	else
	{
		// Check all quadrants
		float strength = shield_get_strength(objp);

		if (strength > MAX(2.0f * objp->n_quadrants, 0.1f * shield_get_max_strength(objp)))
			return 1;
	}

	return 0;	// no shield strength
}