/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * http://www.gnu.org/copyleft/gpl.html
 */
package net.sf.l2j.gameserver.model;

import java.util.List;
import java.util.Random;
import java.util.logging.Logger;

import javolution.util.FastList;
import net.sf.l2j.Config;
import net.sf.l2j.gameserver.ItemTable;
import net.sf.l2j.gameserver.SevenSignsFestival;
import net.sf.l2j.gameserver.serverpackets.InventoryUpdate;
import net.sf.l2j.gameserver.serverpackets.PartySmallWindowAdd;
import net.sf.l2j.gameserver.serverpackets.PartySmallWindowAll;
import net.sf.l2j.gameserver.serverpackets.PartySmallWindowDelete;
import net.sf.l2j.gameserver.serverpackets.PartySmallWindowDeleteAll;
import net.sf.l2j.gameserver.serverpackets.PartySmallWindowUpdate;
import net.sf.l2j.gameserver.serverpackets.ServerBasePacket;
import net.sf.l2j.gameserver.serverpackets.StatusUpdate;
import net.sf.l2j.gameserver.serverpackets.SystemMessage;
import net.sf.l2j.gameserver.skills.Stats;

/**
 * This class ...
 * 
 * @author nuocnam
 * @version $Revision: 1.6.2.2.2.6 $ $Date: 2005/04/11 19:12:16 $
 */
public class L2Party {
    static double[] _bonusExpSp = {1, 1.30, 1.39, 1.50, 1.54, 1.58, 1.63, 1.67, 1.71};
	private static Random _rnd = new Random();

    private static Logger _log = Logger.getLogger(L2Party.class.getName());
    
	private List<L2PcInstance> _members = null;
    private List<L2PcInstance> _validMembers = null;
	private int _partyLvl = 0;
	private int _itemDistribution = 0;
	private int _itemOrder = 0;
	
	public static final int ITEM_LOOTER = 0;
	public static final int ITEM_RANDOM = 1;
	public static final int ITEM_RANDOM_SPOIL = 2;
	public static final int ITEM_ORDER = 3;
	public static final int ITEM_ORDER_SPOIL = 4;
	
	/**
	 * constructor ensures party has always one member - leader
	 * @param leader
	 * @param itemDistributionMode
	 */
	public L2Party(L2PcInstance leader, int itemDistribution) 
    {
		_members = new FastList<L2PcInstance>();
        _validMembers = new FastList<L2PcInstance>();
		_itemDistribution = itemDistribution;
		_members.add(leader);
        _validMembers.add(leader);
		_partyLvl = leader.getLevel();
	}
	
	/**
	 * returns number of party members
	 * @return
	 */
	public int getMemberCount() 
    {
		return _members.size();
	}

    /**
     * returns number of party members
     * @return
     */
    public int getValidMemberCount() 
    {
        return _validMembers.size();
    }

	/**
	 * returns all party members
	 * @return
	 */
	public List<L2PcInstance> getPartyMembers()
    {
		return _members;
	}
	
	/**
	 * get random member from party
	 * @return
	 */
	private L2PcInstance getRandomMember() 
    {
		return _members.get(_rnd.nextInt(_members.size()));
	}

	/**
	 * get next item looter
	 * @return
	 */
	private L2PcInstance getNextLooter()
	{
		int looter = _itemOrder;
		
		_itemOrder++;
		if (_itemOrder > getMemberCount()-1)
			_itemOrder = 0;
		
		return (looter < _members.size()) ? _members.get(looter) : null;
	}

	/**
	 * true if player is party leader
	 * @param player
	 * @return
	 */
	public boolean isLeader(L2PcInstance player) 
    {
		return (_members.get(0).equals(player));
	}
    
    /**
     * Returns the Object ID for the party leader to be used as a unique identifier of this party
     * @return int 
     */
    public int getPartyLeaderOID()
    {
        return _members.get(0).getObjectId();
    }
		
	/**
	 * Broadcasts packet to every party member 
	 * @param msg
	 */
	public void broadcastToPartyMembers(ServerBasePacket msg) 
    {
		for(L2PcInstance member : _members)
		{
			member.sendPacket(msg);
		}
	}

	
	/**
	 * Send a Server->Client packet to all other L2PcInstance of the Party.<BR><BR>
	 */
	public void broadcastToPartyMembers(L2PcInstance player, ServerBasePacket msg) 
    {
		for(L2PcInstance member : _members)
		{
			if (!member.equals(player)) 
            {
				member.sendPacket(msg);
			}
		}
	}
	
	/**
	 * adds new member to party
	 * @param player
	 */
	public void addPartyMember(L2PcInstance player) 
    {		
		//sends new member party window for all members
		//we do all actions before adding member to a list, this speeds things up a little
		PartySmallWindowAll window = new PartySmallWindowAll();
		window.setPartyList(_members);
		player.sendPacket(window);
		
		SystemMessage msg = new SystemMessage(SystemMessage.YOU_JOINED_S1_PARTY);
		msg.addString(_members.get(0).getName());
		player.sendPacket(msg);
		
		msg = new SystemMessage(SystemMessage.S1_JOINED_PARTY);
		msg.addString(player.getName());
		broadcastToPartyMembers(msg);
		broadcastToPartyMembers(new PartySmallWindowAdd(player));
		
		//add player to party, adjust party level
		_members.add(player);
        if (checkMemberValidity(player)) _validMembers.add(player);
		if (player.getLevel() > _partyLvl)
        {
			_partyLvl = player.getLevel();
            recalculateValidMembers();
        }
		//update partySpelled 
		for(L2PcInstance member : _members)
		{
			member.updateEffectIcons();
		}
	}
	
	/**
	 * removes player from party
	 * @param player
	 */
	public void removePartyMember(L2PcInstance player) 
    {
		if (_members.contains(player)) 
        {
			_members.remove(player);
            if (_validMembers.contains(player)) _validMembers.remove(player);
			recalculatePartyLevel();
            
            if (player.isFestivalParticipant())
                SevenSignsFestival.getInstance().updateParticipants(player, this);
			
			SystemMessage msg = new SystemMessage(SystemMessage.YOU_LEFT_PARTY);
			player.sendPacket(msg);
			player.sendPacket(new PartySmallWindowDeleteAll());
			player.setParty(null);
			
			msg = new SystemMessage(SystemMessage.S1_LEFT_PARTY);
			msg.addString(player.getName());
			broadcastToPartyMembers(msg);
			broadcastToPartyMembers(new PartySmallWindowDelete(player));
			
			if (_members.size() == 1) 
            {
				_members.get(0).setParty(null);
			}
		}
	}
	
	/**
	 * Change party leader (used for string arguments)
	 * @param name
	 */
	
	public void changePartyLeader(String name)
	{
		L2PcInstance player = getPlayerByName(name);
		
		if (player != null)
		{
			if (_members.contains(player))
			{
				if (isLeader(player))
				{
                    player.sendPacket(new SystemMessage(SystemMessage.YOU_CANNOT_TRANSFER_RIGHTS_TO_YOURSELF));
				}
				else
				{
					//Swap party members
					L2PcInstance temp;
					int p1 = _members.indexOf(player);
					temp = _members.get(0);
					_members.set(0,_members.get(p1));
					_members.set(p1,temp);
					
					SystemMessage msg = new SystemMessage(SystemMessage.S1_HAS_BECOME_A_PARTY_LEADER);
					msg.addString(_members.get(0).getName());
					broadcastToPartyMembers(msg);
					broadcastToPartyMembers(new PartySmallWindowUpdate(_members.get(0)));
				}
			}
			else
			{
                player.sendPacket(new SystemMessage(SystemMessage.YOU_CAN_TRANSFER_RIGHTS_ONLY_TO_ANOTHER_PARTY_MEMBER));
			}
		}
		
	}

	/**
	 * finds a player in the party by name
	 * @param name
	 * @return
	 */
	private L2PcInstance getPlayerByName(String name) 
    {
		for(L2PcInstance member : _members)
		{
			if (member.getName().equals(name)) return member;
		}
		return null;
	}

	/**
	 * Oust player from party
	 * @param player
	 */
	public void oustPartyMember(L2PcInstance player) 
    {
		if (_members.contains(player)) 
        {
            if (isLeader(player)) 
            {
				removePartyMember(player);
                if(_members.size() > 0)
                {
    				SystemMessage msg = new SystemMessage(SystemMessage.S1_HAS_BECOME_A_PARTY_LEADER);
    				msg.addString(_members.get(0).getName());
    				broadcastToPartyMembers(msg);
    				broadcastToPartyMembers(new PartySmallWindowUpdate(_members.get(0)));
                }
			} 
            else 
            {
				removePartyMember(player);
			}
        }
	}

	/**
	 * Oust player from party
	 * Overloaded method that takes player's name as parameter
	 * @param name
	 */
	public void oustPartyMember(String name) 
    {
		L2PcInstance player = getPlayerByName(name);
		
		if (player != null) 
        {
			if (isLeader(player)) 
            {
				removePartyMember(player);
				SystemMessage msg = new SystemMessage(SystemMessage.S1_HAS_BECOME_A_PARTY_LEADER);
				msg.addString(_members.get(0).getName());
				broadcastToPartyMembers(msg);
				broadcastToPartyMembers(new PartySmallWindowUpdate(_members.get(0)));
			} 
            else 
            {
				removePartyMember(player);
			}
		}
	}
	
	/**
	 * dissolves entire party
	 *
	 */
    /*  [DEPRECATED]
	private void dissolveParty() 
    {
		SystemMessage msg = new SystemMessage(SystemMessage.PARTY_DISPERSED);
		for(int i = 0; i < _members.size(); i++) 
        {
			L2PcInstance temp = _members.get(i);
			temp.sendPacket(msg);
			temp.sendPacket(new PartySmallWindowDeleteAll());
			temp.setParty(null);
		}
	}
    */

	
	/**
	 * distribute item(s) to party members
	 * @param player
	 * @param item
	 */
	public void distributeItem(L2PcInstance player, L2ItemInstance item) 
    {
		L2PcInstance target = null;
		
		switch (_itemDistribution)
		{
		case ITEM_RANDOM:
		case ITEM_RANDOM_SPOIL:
			target = getRandomMember();
			break;
		case ITEM_ORDER:
		case ITEM_ORDER_SPOIL:
			target = getNextLooter();
			break;
		case ITEM_LOOTER:
		default:
			target = player;
			break;
		}
        
        PcInventory inventory = player.getInventory();
        
        if (!inventory.validateCapacity(item))
        {
            if (_itemDistribution == ITEM_RANDOM || _itemDistribution == ITEM_RANDOM_SPOIL)
            {
                while (target == player)
                {
                    target = getRandomMember();
                }
            }
            else if (_itemDistribution == ITEM_ORDER || _itemDistribution == ITEM_ORDER_SPOIL)
            {
                target = getNextLooter();
            }
            else
            {
                if (Config.DEBUG) _log.warning("itemDistribution is ITEM_LOOTER on distributeItem() method");
            }
        }
		
		if (target != null)
		{
		    if (item.getCount() == 1) 
		    {
		        SystemMessage smsg = new SystemMessage(SystemMessage.YOU_PICKED_UP_S1);
		        smsg.addItemName(item.getItemId());
		        target.sendPacket(smsg);
		        
		        smsg = new SystemMessage(SystemMessage.S1_PICKED_UP_S2);
		        smsg.addString(target.getName());
		        smsg.addItemName(item.getItemId());
		        broadcastToPartyMembers(target, smsg);
		    } 
		    else 
		    {
		        SystemMessage smsg = new SystemMessage(SystemMessage.YOU_PICKED_UP_S1_S2);
		        smsg.addNumber(item.getCount());
		        smsg.addItemName(item.getItemId());
		        target.sendPacket(smsg);
		        
		        smsg = new SystemMessage(SystemMessage.S1_PICKED_UP_S2_S3);
		        smsg.addString(target.getName());
		        smsg.addNumber(item.getCount());
		        smsg.addItemName(item.getItemId());
		        broadcastToPartyMembers(target, smsg);
		    }
		    
		    L2ItemInstance item2 = target.getInventory().addItem(item);
		    InventoryUpdate iu = new InventoryUpdate();
		    if (item2.getLastChange() == L2ItemInstance.ADDED) 
		    {
		        iu.addNewItem(item);
		    } 
		    else 
		    {
		        iu.addModifiedItem(item2);
		    }
		    
		    target.sendPacket(iu);
		    
		    StatusUpdate su = new StatusUpdate(target.getObjectId());
		    su.addAttribute(StatusUpdate.CUR_LOAD, target.getCurrentLoad());
		    target.sendPacket(su);
		}
	}
	
	/**
	 * distribute adena to party members
	 * @param adena
	 */
	public void distributeAdena(L2ItemInstance adena) 
    {
        SystemMessage smsg = new SystemMessage(SystemMessage.YOU_PICKED_UP_S1_ADENA);
        
        int[] adenaDist = new int[_members.size()];
        int totalAdena = adena.getCount();
        for(int i=0; i<adenaDist.length; i++)
        {
            int amount = totalAdena / (adenaDist.length - i);
            adenaDist[i] = amount;
            totalAdena -= amount;
            
            smsg.addNumber(adenaDist[i]);
            
            L2ItemInstance newAdena = ItemTable.getInstance().createItem(57);
            newAdena.setCount(adenaDist[i]);
            
            L2PcInstance member = _members.get(i);
            
            //_log.config(member.getName()+" Old adena: "+member.getInventory().getAdena());
            L2ItemInstance item2 = member.getInventory().addItem(newAdena);

            //_log.config(member.getName()+" New adena: "+member.getInventory().getAdena());

            InventoryUpdate iu = new InventoryUpdate();
            if (item2.getLastChange() == L2ItemInstance.ADDED) 
            {
                //_log.config(member.getName()+" update 1 adena: "+adena.getCount());
                iu.addNewItem(adena);
            } 
            else 
            {
                //_log.config(member.getName()+" update 2 adena: "+item2.getCount());
                iu.addModifiedItem(item2);
            }
            member.sendPacket(smsg);
            member.sendPacket(iu);
            
            //_log.config(member.getName()+" "+member.getInventory().getAdena());
        }
	}
		
	
	/**
	 * Distribute Experience and SP rewards to L2PcInstance Party members in the known area of the last attacker.<BR><BR>
	 * 
	 * <B><U> Actions</U> :</B><BR><BR>
	 * <li>Get the L2PcInstance owner of the L2SummonInstance (if necessary) </li>
	 * <li>Calculate the Experience and SP reward distribution rate </li>
	 * <li>Add Experience and SP to the L2PcInstance </li><BR><BR>
	 * 
	 * <FONT COLOR=#FF0000><B> <U>Caution</U> : This method DOESN'T GIVE rewards to L2PetInstance</B></FONT><BR><BR>
	 * 
	 * @param xpReward The Experience reward to distribute
	 * @param spReward The SP reward to distribute
	 * @param rewardedMembers The list of L2PcInstance to reward and LSummonInstance whose owner must be reward
	 * @param lastAttacker The L2Character that has killed the L2Attackable
	 * 
	 */
	public void distributeXpAndSp(int xpReward, int spReward, List<L2Character> rewardedMembers, L2Character lastAttacker) 
    {
        L2SummonInstance summon = null;
        L2PcInstance owner      = null;
        
        float penalty           = 0;
        
        List<L2Character> ToRemove = new FastList<L2Character>();
        
		// Go through the members that must be rewarded
        synchronized(rewardedMembers)
        {
    		for (L2Character member : rewardedMembers)
    		{
                if(ToRemove != null && ToRemove.contains(member))
                {
                    continue;
                }
    			// Check if members are near the last Attacker
    		    if ((member instanceof L2PlayableInstance && lastAttacker.getKnownList().knowsObject(member)) || lastAttacker.getKnownList().knowsThePlayer((L2PcInstance)member))
    			{
    				penalty = 0;
    				
    				// The reward can only be given to a L2PcInstance that owns the L2SummonInstance
    				// The Summon and the L2PcInstance are in the rewarded members table, but it's impossible to know which one is first
    				// That's why only one of them must be used (remove the other during the calculation of the first)
    				if (member instanceof L2SummonInstance)
    				{
                        summon  = (L2SummonInstance)member;
    					penalty = summon.getExpPenalty();
                        owner   = summon.getOwner();
                        
    					// Remove the owner from the rewarded members
    					if (rewardedMembers.contains(owner))
                            ToRemove.add(owner);
    				}
                    else if (member instanceof L2PcInstance)
                    { 
                        owner   = (L2PcInstance)member;
    					
    					// The L2SummonInstance penalty is only applied if it has hit the L2Attackable
                        if (owner.getPet() instanceof L2SummonInstance && rewardedMembers.contains(owner.getPet()))
                        {
                            summon     = (L2SummonInstance)owner.getPet();
                            penalty    = summon.getExpPenalty();
    						
    						// Remove the L2SummonInstance from the rewarded members
                            ToRemove.add(summon);
                        }
    				}
                    
    				// Calculate and add the EXP and SP reward to the member
                    if (_validMembers.contains(member))
                        giveRewardsToMember(member, xpReward, spReward, penalty);
    			}
    		}
        }
	}
	
    /**
     * Calculates and gives final XP and SP rewards to the party member.<BR>
     * This method takes in consideration number of members, members' levels, rewarder's level and bonus modifier for the actual party.<BR><BR>
     * 
     * @param member is the L2Character to be rewarded
     * @param xpReward is the total amount of XP to be "splited" and given to the member
     * @param spReward is the total amount of SP to be "splited" and given to the member
     * @param penalty is the penalty that must be applied to the XP rewards of the requested member
     */
    
    private void giveRewardsToMember(L2Character member, int xpReward, int spReward, float penalty)
    {
        double xpToReward = 0;
        double spToReward = 0;
        double sum = 0;
        double sqd = 0;
        
        for (L2PcInstance character : _validMembers)
        {
            sum += (character.getLevel() * character.getLevel());
        }
        sqd = member.getLevel() * member.getLevel();
        xpToReward = (xpReward * (sqd/sum) * getExpBonus()) * (1 - penalty);
        spToReward = (spReward * (sqd/sum) * getSpBonus()) * (1 - penalty);
        
        // Add the XP/SP points to the requested party member
        member.addExpAndSp((int)member.calcStat(Stats.EXPSP_RATE, xpToReward, null, null), 
                           (int)member.calcStat(Stats.EXPSP_RATE, spToReward, null, null));
    }
    
	/**
	 * refresh party level
	 *
	 */
	public void recalculatePartyLevel() 
    {
		int newLevel = 0;
		for (L2PcInstance member : _members)
		{
			if (member.getLevel() > newLevel)
				newLevel = member.getLevel();
		}
		_partyLvl = newLevel;
        
        recalculateValidMembers();
	}
	
    /**
     * refresh party valid members
     *
     */
    public void recalculateValidMembers()
    {
        _validMembers.clear();
        for (L2PcInstance member : _members)
        {
            if (checkMemberValidity(member)) _validMembers.add(member);
        }
    }
    
    private boolean checkMemberValidity(L2PcInstance member)
    {
//      Fixed LevelDiff cutoff point
        if (Config.PARTY_XP_CUTOFF_METHOD.equalsIgnoreCase("level"))
        {
            return (getLevel() - member.getLevel() <= Config.PARTY_XP_CUTOFF_LEVEL);
        }
//      Fixed MinPercentage cutoff point
        else if (Config.PARTY_XP_CUTOFF_METHOD.equalsIgnoreCase("percentage")) 
        {
            int sqLevel = member.getLevel() * member.getLevel();
            int sum = 0;
            for (L2PcInstance character : _members)
            {
                sum += (character.getLevel() * character.getLevel());
            }
            return (sqLevel * 100 >= sum * Config.PARTY_XP_CUTOFF_PERCENT);
        }
//      Automatic cutoff method
        else if (Config.PARTY_XP_CUTOFF_METHOD.equalsIgnoreCase("auto")) 
        {
            int sqLevel = member.getLevel() * member.getLevel();
            int sum = 0;
            for (L2PcInstance character : _members)
            {
                sum += (character.getLevel() * character.getLevel());
            }
            
            int i = getMemberCount() -1;
            if (i < 1 ) return true;
            if (i >= _bonusExpSp.length) i = _bonusExpSp.length -1;

            return (sqLevel >= sum * (1-1/(1 +_bonusExpSp[i] -_bonusExpSp[i-1])));
        }
        return true;
    }
    
	private double getExpBonus()
	{
		int i = getValidMemberCount() -1;
		if (i < 1 ) return 1;
        if (i >= _bonusExpSp.length) i = _bonusExpSp.length -1;
        
		return _bonusExpSp[i] * Config.RATE_PARTY_XP;
	}
    
    private double getSpBonus()
    {
        int i = getValidMemberCount() -1;
        if (i < 1 ) return 1;
        if (i >= _bonusExpSp.length) i = _bonusExpSp.length -1;
        
        return _bonusExpSp[i] * Config.RATE_PARTY_SP;
    }
	
	public int getLevel()
	{
		return _partyLvl;
	}
    
    public int getLootDistribution()
    {
        return _itemDistribution;
    }
	
	public boolean isDistributeSpoilLoot()
	{
		boolean rv = false;
		
		if (_itemDistribution == ITEM_RANDOM_SPOIL || _itemDistribution == ITEM_ORDER_SPOIL)
			rv = true;
		
		return rv;
	}
}