/*
 * 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 3 of the License, 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, see <http://www.gnu.org/licenses/>.
 */
/**
	coded by Balancer
	balancer@balancer.ru
	http://balancer.ru

	version 0.1, 2005-03-12
*/

package net.sf.l2j.gameserver.model;

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

import javolution.util.FastList;
import net.sf.l2j.util.Rnd;

public class L2Territory
{
	private static Logger _log = Logger.getLogger(L2Territory.class.getName());

	protected class Point
	{
		protected int _x, _y, _zmin, _zmax, _proc;
		Point (int x, int y, int zmin, int zmax, int proc)
		{
			_x=x;
			_y=y;
			_zmin=zmin;
			_zmax=zmax;
			_proc=proc;
		}
	}

	private List<Point> _points;
	private int _terr;
	private int _xMin;
	private int _xMax;
	private int _yMin;
	private int _yMax;
	private int _zMin;
	private int _zMax;
	private int _procMax;

	public L2Territory(int terr)
	{
		_points = new FastList<Point>();
		_terr = terr;
		_xMin = 999999;
		_xMax =-999999;
		_yMin = 999999;
		_yMax =-999999;
		_zMin = 999999;
		_zMax =-999999;
		_procMax = 0;
	}

	public void add(int x, int y, int zmin, int zmax, int proc)
	{
		_points.add(new Point(x,y,zmin,zmax,proc));
		if(x<_xMin) _xMin = x;
		if(y<_yMin) _yMin = y;
		if(x>_xMax) _xMax = x;
		if(y>_yMax) _yMax = y;
		if(zmin<_zMin) _zMin = zmin;
		if(zmax>_zMax) _zMax = zmax;
		_procMax += proc;
	}

	public void print()
	{
		for(Point p : _points)
			_log.info("(" + p._x + "," + p._y + ")");
	}

	public boolean isIntersect(int x, int y, Point p1, Point p2)
	{
		double dy1 = p1._y - y;
		double dy2 = p2._y - y;

		if(Math.signum(dy1) == Math.signum(dy2))
			return false;

		double dx1 = p1._x - x;
		double dx2 = p2._x - x;

		if(dx1 >= 0 && dx2 >= 0)
			return true;

		if(dx1 < 0 && dx2 < 0)
			return false;

		double dx0 = (dy1 * (p1._x-p2._x))/(p1._y-p2._y);

		return dx0 <= dx1;
	}

	public boolean isInside(int x, int y)
	{
		int intersect_count = 0;
		for(int i=0; i<_points.size(); i++)
		{
			Point p1 = _points.get(i>0 ? i-1 : _points.size()-1);
			Point p2 = _points.get(i);

			if(isIntersect(x,y,p1,p2))
				intersect_count++;
	   	}

		return intersect_count%2 == 1;
	}

	public int[] getRandomPoint()
	{
		int[] p = new int[4];
		if ( _procMax>0)
		{
		    int pos = 0;
		    int rnd = Rnd.nextInt(_procMax);
		    for(Point p1: _points)
		    {
				pos += p1._proc;
				if ( rnd <= pos )
				{
				    p[0] = p1._x;
				    p[1] = p1._y;
				    p[2] = p1._zmin;
				    p[3] = p1._zmax;
				    return p;
				}
		    }

		}
		for(int i=0; i<100; i++)
		{
			p[0] = Rnd.get(_xMin, _xMax);
			p[1] = Rnd.get(_yMin, _yMax);
			if(isInside(p[0],p[1]))
			{
			    double curdistance = 0;
			    p[2] = _zMin+100;
			    p[3] = _zMax;
			    for(Point p1: _points)
			    {
					double dx = p1._x-p[0];
					double dy = p1._y-p[1];
					double distance = Math.sqrt(dx*dx+dy*dy);
					if (curdistance == 0 || distance < curdistance)
					{
					    curdistance = distance;
					    p[2] = p1._zmin+100;
					}
			    }
			    return p;
			}
		}
		_log.warning("Can't make point for territory"+_terr);
		return p;
	}
    public int getProcMax()
	{
	    return _procMax;
	}
}
