//----------------------------------------------------------------------
//	ナンバーエリア（四角に切れ）
//
//	Copyright(C) 1996 Hirofumi Fujiwara 
//	本プログラムは、改造も含め、その商用利用は禁止します。
//----------------------------------------------------------------------

import java.awt.*;
import java.applet.*;
import java.lang.*;
import java.io.*;
import java.util.*;
import java.net.*;

public class NumberArea extends Applet {
	final	int	XLIM = 30;
	final	int	YLIM = 30;
	final	int	VERTEX_POS = 1;
	final	int	EDGE_POS   = 2;
	final	int	FACE_POS   = 3;
	final	int	DRAG_START = 4;
	final	int	DRAGGING   = 5;
	final	int	DRAG_END   = 6;
	static  Dimension  app_size;		// アプレットのサイズ
	static	int	xn, yn, unit, wd;	// サイズ、マズサイズ、線幅
	static	int	bd_off;			// 盤のボーダーオフセット

	//  領域面積：初期化時に、数値の与えられた個所にだけ面積が入り、他は０
	public  int	areanum[][];
	// 領域識別番号：初期化時に、数字のある個所だけ識別番号が入り、他は０
	public  int	areaid[][];

	// 領域所属番号：初期化時に、全て０。＋は確定領域、−は部分領域
	public  int	belongto[][];

	public  int	ansid[][];

	public	Area	areainfo[];
	public	int	areacount;

		int	updatetype = 0;
		Point	mixPosition;
		Point	dragStart, dragEnd, dragNew;
		Point	pivot;		// 有効領域のときの数値の書かれている位置
		int	pivotId;	
		int	invalidlist[][]   = new int[XLIM*YLIM][2];
		int	invalidcount;

	final	Color	backcolor  = Color.white;
	final	Color	guidecolor = new Color( 0xcf, 0xcf, 0xcf );
	final	Color	echocolor  = Color.cyan;
	final	Color	fixedcolor = new Color( 0x3f, 0xaf, 0x3f );
	final	Color	subcolor   = new Color( 0xdf, 0xaf, 0x5f );

		Font	areafont;

	public void init() {
		String filename = getParameter( "problemfile" );
		loadData( filename );

		app_size = this.size();
		unit = (int)(app_size.width*0.92)/xn;
		wd = (unit+40)/20;

		setLayout( new BorderLayout() );

		setBackground( Color.white );

		bd_off = ( app_size.width - unit * xn ) / 2;

		Label  copyright = new Label("Number Area V0.12" + "  " + 
						"Copyright(C)1996 Hirofumi Fujiwara.",
					Label.CENTER );
		add( "South", copyright );
//		copyright.reshape( 0, app_size.height-22, app_size.width, 20 );
	}

	//----------------------------------------------------------------
	//	ボードの配列を確保する
	void newBoard() {
		areanum   = new int[xn][yn];
		areaid    = new int[xn][yn];
		ansid     = new int[xn][yn];
		belongto  = new int[xn][yn];
	}

	//----------------------------------------------------------------
	//	領域で長方形データの配列を確保し、初期化する
	void newArea() {
		areacount = 0;
		for( int x=0; x<xn; ++x )
			for( int y=0; y<yn; ++y ) {
				if( areanum[x][y] != 0 )
					++areacount;
			}

		areainfo = new Area[areacount+1];

		int n = 0;
		for( int x=0; x<xn; ++x )
			for( int y=0; y<yn; ++y ) {
				int  s = areanum[x][y];
				if(  s != 0 ) {
					areaid[x][y] = ++n;
					areainfo[n] = new Area( x, y, s );
				}
			}
	}

	//----------------------------------------------------------------
	//	問題、解答の読み込み
	void loadData( String filename ) {
		URL		url;
		DataInputStream file;
		try {
			url = new URL( getDocumentBase(), filename );
			file = new DataInputStream( url.openStream() );
		} catch( MalformedURLException e ) {
			showStatus( "file name error : " + filename );
			return;
		} catch( IOException e ) {
			showStatus( "file open error : " + filename );
			return;
		}

		String line;

		try {
			boolean	isproblem = false;
			boolean	isanswer  = false;
			int x, y=0, v;

		    nextline:
			for(;;) {
				line=file.readLine();
				if( line == null )
					break;
				if( '#' == line.charAt(0) )
					continue;

				StringTokenizer st = new StringTokenizer(line);
				try {
					String tk = st.nextToken();
					if( tk.equals("size") ) {
						tk = st.nextToken();
						xn = (Integer.valueOf(tk)).intValue();
						tk = st.nextToken();
						yn = (Integer.valueOf(tk)).intValue();
						newBoard();	// データ領域の確保
						continue nextline;
					}

					if( tk.equals("problem") ) {
						isproblem = true;
						areacount = 0;
						continue nextline;
					}
					if( tk.equals("answer") ) {
						isproblem = false;
						isanswer  = true;
						y = 0;
						continue nextline;
					}
					if( tk.equals("end") ) {
						break nextline;
					}

					if( isproblem ) {
						x = (Integer.valueOf(tk)).intValue();
						tk = st.nextToken();
						y = (Integer.valueOf(tk)).intValue();
						tk = st.nextToken();
						v = (Integer.valueOf(tk)).intValue();
						areanum[x][y] = v;

					} else if( isanswer ) {
						for( x=0; ; ++x ) {
							v = (Integer.valueOf(tk)).intValue();
							ansid[x][y] = v;
							tk = st.nextToken();
						}
					}
				} catch( NoSuchElementException e ) {}
				++y;
			}
		} catch( IOException e ) {}

		newArea();
	}

	//----------------------------------------------------------------
	// ビット画面上への位置変換
	int	toPos( int i ) {
		return	bd_off + i * unit - wd/2;
	}

	int	toXPos( int i ) {
		return	bd_off + i * unit;
	}

	//----------------------------------------------------------------
	// ビット画面上の座標から、頂点/稜線/面（ミックス系）の位置番号に変換
	Point	mixPos( int x, int y ) {
		int	mx = 0, my =0;
		double	delta = 0.15d;
		double	dx = (double)(x - bd_off) / unit;
		double	dy = (double)(y - bd_off) / unit;

		if( delta<dx && dx<xn-delta && delta<dy && dy<yn-delta ) {

			if( Math.abs( dx - Math.round(dx) ) < delta )
				mx = (int)Math.round(dx) * 2;
			else
				mx = ((int)dx)*2 + 1 ;

			if( Math.abs( dy - Math.round(dy) ) < delta )
				my = (int)Math.round(dy) * 2;
			else
				my = ((int)dy)*2 + 1 ;
		}

		return	new Point( mx, my );
	}

	boolean isInside( Point p ) {
		return  ( 0<=p.x && p.x<xn && 0<=p.y && p.y<yn );
	}

	Point	boxPos( int x, int y ) {
		int i = (x - bd_off) / unit;
		int j = (y - bd_off) / unit;

		return	new Point( i, j );
	}

	void  clearRectArea( Graphics g, int aid ) {
		int	idx = Math.abs(aid);

		int	sx = areainfo[idx].p0.x;
		int	sy = areainfo[idx].p0.y;
		int	ex = areainfo[idx].p1.x;
		int	ey = areainfo[idx].p1.y;

		for( int x=sx; x<=ex; ++x )
			for( int y=sy; y<=ey; ++y )
				belongto[x][y] = 0;

		paintFace( g, new Point(sx,sy), new Point(ex,ey), backcolor );
		if( idx != 0 )
			areainfo[idx].ClearArea();
	}

	void  printBorad() {
		System.out.println( "----printBorad----");
		for( int y=0; y<yn; ++y ) {
			for( int x=0; x<xn; ++x ) {
				System.out.print( "  "+belongto[x][y] );
			}
			System.out.println();
		}
		System.out.println( "------------------");
	}

	//----------------------------------------------------------------
	//  長方形の対角点を与えて、この長方形領域を指定のIdにする
	//	Id指定なしは、クリア。Idが負の時は部分領域とする。

	void  fillId( Graphics g, Point p0, Point p1 ) {
		fillId( g, p0, p1, 0 );
	}

	void  fillId( Graphics g, Point p0, Point p1, int id ) {
		int	sx = Math.min( p0.x, p1.x );
		int	sy = Math.min( p0.y, p1.y );
		int	ex = Math.max( p0.x, p1.x );
		int	ey = Math.max( p0.y, p1.y );

		for( int x=sx; x<=ex; ++x ) {
			for( int y=sy; y<=ey; ++y ) {
				int aid = belongto[x][y];
				if( aid != 0 ) {
					clearRectArea( g, aid );
				}
			}
		}

		for( int x=sx; x<=ex; ++x ) {
			for( int y=sy; y<=ey; ++y ) {
				belongto[x][y] = id;
			}
		}
	}

	//----------------------------------------------------------------
	//  長方形の対角点を与えて、この長方形の正当性を求める
	int  isValid( Point p0, Point p1 ) {
		int	sx = Math.min( p0.x, p1.x );
		int	sy = Math.min( p0.y, p1.y );
		int	ex = Math.max( p0.x, p1.x );
		int	ey = Math.max( p0.y, p1.y );
		int	s = (ex - sx + 1) * (ey - sy + 1);
		int	n = 0;
		int	stat = Area.INVALID;
		int	i, j;
		for( int x=sx; x<=ex; ++x ) {
			for( int y=sy; y<=ey; ++y ) {
				int a = areanum[x][y];
				if( a == 0 )
					continue;
				++n;
				pivot = new Point( x, y );
				pivotId = areaid[x][y];

				if( a == s )
					stat = Area.FIXAREA;
				if( s < a )
					stat = Area.SUBAREA;
			}
		}

		if( n != 1 )
			stat = Area.INVALID;

		return	stat;
	}

	//----------------------------------------------------------------
	// 現在の領域の有効性を調べ、描画も行なう
	void	checkValidityUpdate( Graphics g ) {
		switch( isValid( dragStart, dragEnd ) ) {
		case Area.INVALID:
			fillId( g, dragStart, dragEnd, 0 );
			paintFace( g, dragStart, dragEnd, backcolor );
			break;
		case Area.SUBAREA:
			fillId( g, dragStart, dragEnd, -pivotId );	// サブエリアは負数
			areainfo[pivotId].SetArea( dragStart, dragEnd, Area.SUBAREA );
			paintFace( g, dragStart, dragEnd, subcolor );
			paintFixEdge( g, dragStart, dragEnd );
			break;
		case Area.FIXAREA:
			fillId( g, dragStart, dragEnd, pivotId );
			areainfo[pivotId].SetArea( dragStart, dragEnd, Area.FIXAREA );
			paintFace( g, dragStart, dragEnd, fixedcolor );
			paintFixEdge( g, dragStart, dragEnd );
			break;
		}
	}

	void  paintFixEdge( Graphics g ) {
		Point p0 = new Point( 0, 0 );
		Point p1 = new Point( xn-1, yn-1 );

		paintFixEdge( g, p0, p1 );
	}

	void  paintFixEdge( Graphics g, Point p0, Point p1 ) {
		g.setColor( Color.black );

		int	sx = Math.min( p0.x, p1.x );
		int	sy = Math.min( p0.y, p1.y );
		int	ex = Math.max( p0.x, p1.x );
		int	ey = Math.max( p0.y, p1.y );

		g.fillRect( toPos(sx),   toPos(sy),   wd, (ey-sy+1)*unit+wd );
		g.fillRect( toPos(ex+1), toPos(sy),   wd, (ey-sy+1)*unit+wd );
		g.fillRect( toPos(sx),   toPos(sy),   (ex-sx+1)*unit+wd, wd );
		g.fillRect( toPos(sx),   toPos(ey+1), (ex-sx+1)*unit+wd, wd );
	}

	//----------------------------------------------------------------
	// マスの１区画を塗る
	void  paintFace( Graphics g, Point pos, Color c ) {
		g.setColor( c );
		g.fillRect( toPos(pos.x)+wd, toPos(pos.y)+wd, unit-wd, unit-wd ); 

		// 必要ならば数字を描く
		int  v = areanum[pos.x][pos.y];
		if( v != 0 ) {
			drawNumber( g, pos.x, pos.y, v );
		}
	}

	void  paintFace( Graphics g, Point spos, Point epos, Color c ) {
		int	sx = spos.x;
		int	sy = spos.y;
		int	ex = epos.x;
		int	ey = epos.y;
		if( sx > ex ) {
			int w=sx; sx=ex; ex=w;
		}
		if( sy > ey ) {
			int w=sy; sy=ey; ey=w;
		}

		g.setColor( guidecolor );
		g.fillRect( toPos(sx)+wd, toPos(sy)+wd, 
				(ex-sx+1)*unit-wd, (ey-sy+1)*unit-wd );

		g.setColor( c );
		for( int i=sx; i<=ex; ++i )
			for( int j=sy; j<=ey; ++j )
				paintFace( g, new Point( i, j ), c );
	}

	void drawNumber( Graphics g, int x, int y, int v ) {
		if( v == 0 )
			return;
		if( areafont == (Font)null ) {
			areafont = new java.awt.Font( "Helvetica", 0, unit*8/10 );
		}

		g.setColor( Color.black );
		g.setFont( areafont );
		String s = String.valueOf(v);
		FontMetrics fm = g.getFontMetrics();
		int	sWidth = fm.stringWidth(s);
		int	sHeight = fm.getHeight();
		int	sAscent = fm. getAscent();
		g.drawString( s, toXPos(x)+(unit-sWidth)/2, toXPos(y)+(unit+sAscent)/2-1 );
	}

	//----------------------------------------------------------------
	// マウス・ダウン
	public boolean mouseDown( Event evt, int x, int y ) {
		Point p = boxPos( x, y );
		if( isInside( p ) ) {
			dragStart = dragEnd = dragNew = p;
			updatetype = DRAG_START;
			repaint();
		}
		return	true;
	}

	//----------------------------------------------------------------
	// マウス・ドラッグ
	public boolean mouseDrag( Event evt, int x, int y ) {
		Point bp = dragNew = boxPos( x, y );

		if( ! (updatetype == DRAG_START || updatetype == DRAGGING ) )
			return	true;
		if( ! isInside( bp ) )
			return	true;
		if( dragEnd.x == bp.x && dragEnd.y == bp.y )
			return	true;

		updatetype = DRAGGING;
		repaint();
		return	true;
	}

	//----------------------------------------------------------------
	// マウス・アップ
	public boolean mouseUp( Event evt, int x, int y ) {
		if( updatetype == DRAG_START || updatetype == DRAGGING ) {
			updatetype = DRAG_END;
			repaint();
		} else {
			updatetype = 0;
		}
		return	true;
	}

	//----------------------------------------------------------------
	// アップデイト
	public void update( Graphics g ) {
		switch( updatetype ) {
		case DRAG_START:
			paintFace( g, dragStart, echocolor );
			fillId( g, dragStart, dragStart );
			break;
		case DRAGGING:
			fillId( g, dragStart, dragEnd );
			paintFace( g, dragStart, dragEnd, backcolor );
			dragEnd = dragNew;
			fillId( g, dragStart, dragEnd );
			paintFace( g, dragStart, dragEnd, echocolor );

			break;
		case DRAG_END:
			checkValidityUpdate( g );
			updatetype = 0;
		}
	}

	//----------------------------------------------------------------
	// ペイント
	public void paint( Graphics g ) {
		g.setColor( backcolor );
		g.fillRect( 0, 0, app_size.width, app_size.height );

		g.setColor( guidecolor );
		int	vl = yn*unit+wd;
		for( int i=0; i<=xn; ++i ) {
			g.fillRect( toPos(i), toPos(0), wd, vl );
		}

		int	hl = xn*unit+wd;
		for( int j=0; j<=yn; ++j ) {
			g.fillRect( toPos(0), toPos(j), hl, wd );
		}

		paintFixEdge( g );
		paintFace( g, new Point(0,0), new Point(xn-1,yn-1), backcolor );

		for( int i=1; i<areainfo.length; ++i ) {
			Area ar = areainfo[i];
			switch( ar.state ) {
			case Area.SUBAREA:
				paintFace( g, ar.p0, ar.p1, subcolor );
				paintFixEdge( g, ar.p0, ar.p1 );
				break;
			case Area.FIXAREA:
				paintFace( g, ar.p0, ar.p1, fixedcolor );
				paintFixEdge( g, ar.p0, ar.p1 );
				break;
			}
		}
	}
}

//--------------------------------------------------------------------------------
//	長方形領域クラス
//--------------------------------------------------------------------------------
class  Area {

		int	area;			// 面積
		int	x, y;			// 数値の位置
	public	Point	p0, p1;			// 長方形の位置（ユーザ用）
	public	int	state;			// 状態
	public static final int	INVALID = 0;
	public static final int	SUBAREA = 1;
	public static final int	FIXAREA = 2;

	public	Area( int i, int j, int a ) {
		x = i;
		y = j;
		area = a;
		state = INVALID;
	}

	public void SetArea( Point q0, Point q1, int st ) {
		int  sx = Math.min( q0.x, q1.x );
		int  sy = Math.min( q0.y, q1.y );
		int  ex = Math.max( q0.x, q1.x );
		int  ey = Math.max( q0.y, q1.y );
		p0 = new Point( sx, sy );
		p1 = new Point( ex, ey );
		state = st;
	}

	public void ClearArea() {
		state = INVALID;
	}
}

//--------------------------------------------------------------------------------
//		end of "NumberArea.java",  by Hirofumi Fujiwara
//--------------------------------------------------------------------------------