/**
 * Title: ScreenPlanes.java
 * Copyright:   Copyright (c) 2001
 * Company:
 * @author  Kenneth J. Pouncey
 * @version 0.5
 *
 * Description:
 *
 * 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 software; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307 USA
 *
 */
package org.tn5250j.framework.tn5250;

import static org.tn5250j.TN5250jConstants.*;

import java.util.Properties;

public class ScreenPlanes {

	private final Screen5250 scr;
	private int screenSize;
	private int numRows;
	private int numCols;
	private int errorLineNum;

	private static final int initAttr = 32;
	private static final char initChar = 0;

	protected char[] screen;   // text plane
	private char[] screenAttr;   // attribute plane
	private char[] screenGUI;   // gui plane
	private char[] screenIsAttr;
	private char[] fieldExtended;
	private char[] screenField;
	private char[] screenColor;   // color plane
	protected char[] screenExtended;   // extended plane
	private char[] screenIsChanged;

	private char[] initArray;

	private char[] errorLine;
	private char[] errorLineAttr;
	private char[] errorLineIsAttr;
	private char[] errorLineGui;

	public ScreenPlanes(Screen5250 s5250, int size) {

		scr = s5250;
		setSize(size);
	}

	protected void setSize(int newSize) {

		screenSize = newSize;

		numCols = 80;
		switch (newSize) {
		case 24:
			numRows = 24;
			break;
		case 27:
			numRows = 27;
			numCols = 132;
			break;

		}

		// this is used here when size changes
		setErrorLine(numRows);

		screenSize = numRows * numCols;
		screen = new char[screenSize];
		screenAttr = new char[screenSize];
		screenIsAttr = new char[screenSize];
		screenGUI = new char[screenSize];
		screenColor = new char[screenSize];
		screenExtended = new char[screenSize];
		fieldExtended = new char[screenSize];
		screenIsChanged = new char[screenSize];
		screenField = new char[screenSize];

		initArray = new char[screenSize];

		initalizePlanes();
	}

	protected void setErrorLine (int line) {

		// * NOTE * for developers I have changed the send qry to pass different
		//    parameters to the host so check setsize for setting error line as well.
		//
		if (line == 0 || line > numRows)
			errorLineNum = numRows;
		else
			errorLineNum = line;
	}

	/**
	 * Returns the current error line number
	 *
	 * @return current error line number
	 */
	protected int getErrorLine() {
		return errorLineNum;
	}

	protected void saveErrorLine() {

		// if there is already an error line saved then do not save it again
		//  This signifies that there was a previous error and the original error
		//  line was not restored yet.
		if (errorLine == null) {
			errorLine = new char[numCols];
			errorLineAttr = new char[numCols];
			errorLineIsAttr = new char[numCols];
			errorLineGui = new char[numCols];

			int r = scr.getPos(errorLineNum-1,0);

			for (int x = 0;x < numCols; x++) {
				errorLine[x] = screen[r+x];
				errorLineAttr[x] = screenAttr[r+x];
				errorLineIsAttr[x] = screenIsAttr[r+x];
				errorLineGui[x] = screenGUI[r+x];
			}
		}
	}

	/**
	 * Restores the error line characters from the save buffer.
	 *
	 * @see #saveErrorLine()
	 */
	protected void restoreErrorLine() {

		if (errorLine != null) {
			int r = scr.getPos(errorLineNum - 1, 0);

			for (int x = 0; x < numCols - 1; x++) {
				setScreenCharAndAttr(r+x,errorLine[x],errorLineAttr[x],
						(errorLineIsAttr[x] == '1' ? true : false));
				screenGUI[x] = errorLineGui[x];
			}

			errorLine = null;
			errorLineAttr = null;
			errorLineIsAttr = null;
			errorLineGui = null;
		}
	}

	protected boolean isErrorLineSaved() {
		return errorLine == null ? false : true;
	}

	protected void setScreenCharAndAttr(int pos, char c, int attr, boolean isAttr) {

		screen[pos] = c;
		screenAttr[pos] = (char)attr;
		disperseAttribute(pos,attr);
		screenIsAttr[pos] = (isAttr ? (char)1 : (char)0);
		screenGUI[pos] = NO_GUI;

	}

	protected void setScreenAttr(int pos, int attr, boolean isAttr) {

		screenAttr[pos] = (char)attr;
		screenIsAttr[pos] = isAttr ? (char)1 : (char)0;
		disperseAttribute(pos,attr);
		screenGUI[pos] = initChar;

	}

	protected void setScreenAttr(int pos, int attr) {

		screenAttr[pos] = (char)attr;
		//screenGUI[pos] = initChar;
		disperseAttribute(pos,attr);

	}

	protected void setScreenFieldAttr(int pos, int attr) {

		screenField[pos] = (char)attr;

	}

	protected final void setChar(int pos, char c) {
		screenIsChanged[pos] = screen[pos] == c ? '0' : '1';
		screen[pos] = c;
		if (screenIsAttr[pos] == 1)
			setScreenCharAndAttr(pos,c,32,false);

	}

	protected final char getChar(int pos) {
		return screen[pos];
	}

	protected final char getCharColor(int pos) {
		return screenColor[pos];
	}

	protected final int getCharAttr(int pos) {
		return screenAttr[pos];
	}

	protected final int getCharExtended(int pos) {
		return screenExtended[pos];
	}

	protected final boolean isAttributePlace(int pos) {
		return screenIsAttr[pos] == 1 ? true : false;
	}

	public final void setUseGUI(int pos, int which) {

		screenIsChanged[pos] = screenGUI[pos] == which ? '0' : '1';
		screenGUI[pos] = (char)which;
	}

	private void disperseAttribute(int pos, int attr) {

		char c = 0;
		char cs = 0;
		char ul = 0;
		char nd = 0;

		if(attr == 0)
			return;

		switch(attr) {
		case 32: // green normal
			c = ATTR_32;
			break;

		case 33: // green/revers
			c = ATTR_33;
			break;

		case 34: // white normal
			c = ATTR_34;
			break;

		case 35: // white/reverse
			c = ATTR_35;
			break;

		case 36: // green/underline
			c = ATTR_36;
			ul = EXTENDED_5250_UNDERLINE;
			break;

		case 37: // green/reverse/underline
			c = ATTR_37;
			ul = EXTENDED_5250_UNDERLINE;
			break;

		case 38: // white/underline
			c = ATTR_38;
			ul = EXTENDED_5250_UNDERLINE;
			break;

		case 39:
			nd = EXTENDED_5250_NON_DSP;
			break;

		case 40:
		case 42: // red/normal
			c = ATTR_40;
			break;

		case 41:
		case 43: // red/reverse
			c = ATTR_41;
			break;

		case 44:
		case 46: // red/underline
			c = ATTR_44;
			ul = EXTENDED_5250_UNDERLINE;
			break;

		case 45: // red/reverse/underline
			c = ATTR_45;
			ul = EXTENDED_5250_UNDERLINE;
			break;

		case 47:
			nd = EXTENDED_5250_NON_DSP;
			break;

		case 48:
			c = ATTR_48;
			cs = EXTENDED_5250_COL_SEP;
			break;

		case 49:
			c = ATTR_49;
			cs = EXTENDED_5250_COL_SEP;
			break;

		case 50:
			c = ATTR_50;
			cs = EXTENDED_5250_COL_SEP;
			break;

		case 51:
			c = ATTR_51;
			cs = EXTENDED_5250_COL_SEP;
			break;

		case 52:
			c = ATTR_52;
			//            colSep = true;
			ul = EXTENDED_5250_UNDERLINE;
			break;

		case 53:
			c = ATTR_53;
			//            colSep = true;
			ul = EXTENDED_5250_UNDERLINE;
			break;

		case 54:
			c = ATTR_54;
			//            colSep = true;
			ul = EXTENDED_5250_UNDERLINE;
			break;

		case 55:
			nd = EXTENDED_5250_NON_DSP;
			break;

		case 56: // pink
			c = ATTR_56;
			break;

		case 57: // pink/reverse
			c = ATTR_57;
			break;

		case 58: // blue/reverse
			c = ATTR_58;
			break;

		case 59: // blue
			c = ATTR_59;
			break;

		case 60: // pink/underline
			c = ATTR_60;
			ul = EXTENDED_5250_UNDERLINE;
			break;

		case 61: // pink/reverse/underline
			c = ATTR_61;
			ul = EXTENDED_5250_UNDERLINE;
			break;

		case 62: // blue/underline
			c = ATTR_62;
			ul = EXTENDED_5250_UNDERLINE;
			break;

		case 63:  // nondisplay
			nd = EXTENDED_5250_NON_DSP;
			cs = EXTENDED_5250_COL_SEP;
			break;
		default:
			c = ( COLOR_BG_BLACK << 8 & 0xff00) |
			( COLOR_FG_YELLOW & 0xff);
			break;

		}

		screenColor[pos] = c;
		screenExtended[pos] = (char)(ul | cs | nd);
	}

	protected void initalizePlanes () {

		char c = (COLOR_BG_BLACK << 8 & 0xff00) |
		(COLOR_FG_GREEN & 0xff);

		for (int y = 0;y < screenSize; y++) {

			screenAttr[y] = initAttr;
			screenColor[y] = c;

		}

		// here we will just copy the initialized plane onto the other planes
		// using arraycopy which will be faster.  I hope.

		System.arraycopy(initArray,0,screen,0,screenSize);
		System.arraycopy(initArray,0,screenGUI,0,screenSize);
		System.arraycopy(initArray,0,screenIsAttr,0,screenSize);
		System.arraycopy(initArray,0,screenExtended,0,screenSize);
		System.arraycopy(initArray,0,fieldExtended,0,screenSize);
		System.arraycopy(initArray,0,screenField,0,screenSize);
	}

	protected void initalizeFieldPlanes () {
		System.arraycopy(initArray,0,fieldExtended,0,screenSize);
		System.arraycopy(initArray,0,screenField,0,screenSize);
	}

	protected final int getWhichGUI(int pos) {

		return screenGUI[pos];
	}

	protected final boolean isChanged(int pos) {
		return screenIsChanged[pos] == 0 ? false : true;
	}

	protected final boolean isUseGui(int pos) {
		return screenGUI[pos] == NO_GUI ? false : true;
	}

	/**
	 * Return the data associated with the plane that is passed.
	 *
	 * @param from Position from which to start
	 * @param to Position to end
	 * @param plane From which plane to obtain the data
	 * @return Character array containing the data requested
	 */
	protected synchronized char[] getPlaneData(int from, int to, int plane) {

		int len = (to - from);

		char[] planeChars = new char[len + 1];

		switch (plane) {
		case PLANE_TEXT:
			System.arraycopy(screen, from, planeChars, 0, len);
			break;
		case PLANE_ATTR:
			System.arraycopy(screenAttr, from, planeChars, 0, len);
			break;
		case PLANE_COLOR:
			System.arraycopy(screenColor, from, planeChars, 0, len);
			break;
		case PLANE_EXTENDED:
			System.arraycopy(screenExtended, from, planeChars, 0, len);
			break;
		case PLANE_EXTENDED_GRAPHIC:
			System.arraycopy(screenGUI, from, planeChars, 0, len);
			break;
		case PLANE_FIELD:
			System.arraycopy(screenField, from, planeChars, 0, len);
			break;
		case PLANE_IS_ATTR_PLACE:
			System.arraycopy(screenIsAttr, from, planeChars, 0, len);
			break;
		default:
			System.arraycopy(screen, from, planeChars, 0, len);

		}
		return planeChars;

	}

	/**
	 * Converts a linear presentation space position to its corresponding row.
	 *
	 * @param pos The position to be converted
	 * @return The row which corresponds to the position given
	 * @throws OhioException
	 */
	private int convertPosToRow(int pos) {

		return (pos / numCols) + 1;

	}

	/**
	 * Converts a linear presentation space position to its corresponding column.
	 *
	 * @param pos The position to be converted
	 * @return The column which corresponds to the position given
	 * @throws OhioException
	 */
	private int convertPosToColumn(int pos) {

		return (pos % numCols) + 1;

	}

	/**
	 *
	 * Converts a row and column coordinate to its corresponding linear position.
	 *
	 * @param row - The row of the coordinate
	 * @param col - The column of the coordinate
	 * @return The linear position which corresponds to the coordinate given.
	 * @throws OhioException
	 */
	private int convertRowColToPos(int row, int col) {


		return (row - 1) * numCols + col -1;

	}


	/**
	 * <p>
	 *  GetScreen retrieves the various planes associated with the presentation
	 *  space. The data is returned as a linear array of character values in the
	 *  array provided. The array is not terminated by a null character except
	 *  when data is retrieved from the text plane, in which case a single null
	 *  character is appended.
	 *  </p>
	 *  <p>
	 *  The application must supply a buffer for the returned data and the length
	 *  of the buffer. Data is returned starting from the beginning of the
	 *  presentation space and continuing until the buffer is full or the entire
	 *  plane has been copied. For text plane data, the buffer must include one
	 *  extra position for the terminating null character.
	 *  <p>
	 *
	 * @param buffer
	 * @param bufferLength
	 * @param plane
	 * @return The number of characters copied to the buffer
	 * @throws OhioException
	 */
	public synchronized int GetScreen(char buffer[], int bufferLength, int plane) {

		return GetScreen(buffer,bufferLength,0,screenSize,plane);

	}

	/**
	 * <p>
	 *  GetScreen retrieves the various planes associated with the presentation
	 *  space. The data is returned as a linear array of character values in the
	 *  array provided. The array is not terminated by a null character except
	 *  when data is retrieved from the text plane, in which case a single null
	 *  character is appended.
	 * </p>
	 * <p>
	 * The application must supply a buffer for the returned data and the length
	 * of the buffer. Data is returned starting from the given position and
	 * continuing until the specified number of characters have been copied, the
	 * buffer is full or the entire plane has been copied. For text plane data,
	 * the buffer must include one extra position for the terminating null character.
	 * </p>
	 *
	 * @param buffer
	 * @param bufferLength
	 * @param from
	 * @param length
	 * @param plane
	 * @return The number of characters copied to the buffer
	 * @throws OhioException
	 */
	public synchronized int GetScreen(char buffer[], int bufferLength, int from,
			int length, int plane)
	{
		//      if(buffer == null)
		//         throw new OhioException(sessionVT.getSessionConfiguration(),
		//                     OhioScreen.class.getName(), "osohio.screen.ohio00300", 1);
		if(buffer == null)
			return 0;

		int min = Math.min(Math.min(buffer.length, bufferLength), screenSize);
		if ((from + min) > screenSize) {
			min = screenSize - from;
		}

		char[] pd = getPlaneData(from,from + min,plane);
		if(pd != null) {
			System.arraycopy(pd, 0, buffer, 0, min);
			return pd.length;
		}

		return 0;
	}

	/**
	 * <p>
	 *  GetScreen retrieves the various planes associated with the presentation
	 *  space. The data is returned as a linear array of character values in the
	 *  array provided. The array is not terminated by a null character except
	 *  when data is retrieved from the text plane, in which case a single null
	 *  character is appended.
	 *  </p>
	 *  <p>
	 *  The application must supply a buffer for the returned data and the length
	 *  of the buffer. Data is returned starting from the given coordinates and
	 *  continuing until the specified number of characters have been copied,
	 *  the buffer is full, or the entire plane has been copied. For text plane
	 *  data, the buffer must include one extra position for the terminating null
	 *  character.
	 *  </p>
	 *
	 * @param buffer
	 * @param bufferLength
	 * @param row
	 * @param col
	 * @param length
	 * @param plane
	 * @return The number of characters copied to the buffer.
	 * @throws OhioException
	 */
	public synchronized int GetScreen(char buffer[], int bufferLength, int row,
			int col, int length, int plane)
	//                                       throws OhioException {
	{
		// Call GetScreen function after converting row and column to
		// a position.
		return GetScreen(buffer,bufferLength, convertRowColToPos(row,col),
				length, plane);
	}

	/**
	 * <p>
	 *  GetScreenRect retrieves data from the various planes associated with the
	 *  presentation space. The data is returned as a linear array of character
	 *  values in the buffer provided.
	 *  </p>
	 *
	 * <p>
	 * The application supplies two positions that represent opposing corners of
	 * a rectangle within the presentation space. The starting and ending
	 * positions can have any spatial relationship to each other. The data
	 * returned starts from the row containing the upper-most point to the row
	 * containing the lower-most point, and from the left-most column to the
	 * right-most column.
	 * </p>
	 * <p>
	 * The specified buffer must be at least large enough to contain the number
	 * of characters in the rectangle. If the buffer is too small, no data is
	 * copied and zero is returned by the method. Otherwise, the method returns
	 * the number of characters copied.
	 * </p>
	 *
	 * @param buffer
	 * @param bufferLength
	 * @param startPos
	 * @param endPos
	 * @param plane
	 * @return The number of characters copied to the buffer
	 * @throws OhioException
	 */
	protected int GetScreenRect(char buffer[], int bufferLength,
			int startPos, int endPos, int plane)
	//                                             throws OhioException {
	{
		// We will use the row,col routine here because it is easier to use
		// row colum than it is for position since I wrote the other first and
		// am to lazy to implement it here
		// Maybe it would be faster to do it the other way?
		int startRow = convertPosToRow(startPos);
		int startCol = convertPosToColumn(startPos);
		int endRow = convertPosToRow(endPos);
		int endCol = convertPosToColumn(endPos);
		return GetScreenRect(buffer, bufferLength, startRow, startCol,
				endRow, endCol, plane);

	}

	/**
	 * <p>
	 *  GetScreenRect retrieves data from the various planes associated with the
	 *  presentation space. The data is returned as a linear array of character
	 *  values in the buffer provided. The buffer is not terminated by a null
	 *  character.
	 * </p>
	 * <p>
	 * The application supplies two coordinates that represent opposing corners
	 * of a rectangle within the presentation space. The starting and ending
	 * coordinates can have any spatial relationship to each other. The data
	 * returned starts from the row containing the upper-most point to the row
	 * containing the lower-most point, and from the left-most column to the
	 * right-most column.
	 * </p>
	 * <p>
	 * The specified buffer must be at least large enough to contain the number
	 * of characters in the rectangle. If the buffer is too small, no data is
	 * copied and zero is returned by the method. Otherwise, the method returns
	 * the number of characters copied.
	 * </p>
	 *
	 * @param buffer
	 * @param bufferLength
	 * @param startRow
	 * @param startCol
	 * @param endRow
	 * @param endCol
	 * @param plane
	 * @return The number characters copied to the buffer
	 * @throws OhioException
	 */
	protected int GetScreenRect(char buffer[], int bufferLength,
			int startRow, int startCol,
			int endRow, int endCol, int plane)
	//                                             throws OhioException {
	{
		// number of bytes obtained
		int numBytes = 0;

		// lets check the row range.  If they are reversed then we need to
		// place them in the correct order.
		if(startRow > endRow) {
			int r = startRow;
			startRow = endRow;
			endRow = r;
		}
		// lets check the column range.  If they are reversed then we need to
		// place them in the correct order.
		if(startCol > endCol) {
			int c = startCol;
			startCol = endCol;
			endCol = c;
		}
		int numCols = (endCol - startCol) + 1;
		int numRows = (endRow - startRow) + 1;

		// lets make sure it is within the bounds of the character array passed
		//  if not the return as zero bytes where read as per documentation.
		if(numCols * numRows <= bufferLength) {

			// make sure it is one larger.  I guess for other languanges to
			// reference like in C which is terminated by a zero byte at the end
			// of strings.
			char cb[] = new char[numCols + 1];
			int charOffset = 0;
			int bytes = 0;

			// now let's loop through and get the screen information for
			//  each row;
			for(int row = startRow; row <= endRow;) {
				if((bytes = GetScreen(cb, cb.length, row, startCol, numCols, plane)) != 0) {
					System.arraycopy(cb, 0, buffer, charOffset, numCols);
				}
				row++;
				charOffset += numCols;
				// make sure we count the number of bytes returned
				numBytes += bytes;
			}

		}

		return numBytes;
	}

	private int isOption(char[] screen,
			int x,
			int lenScreen,
			int numPref,
			int numSuff,
			char suff) {
		boolean hs =true;
		int sp = x;
		int os = 0;
		// check to the left for option
		while (--sp >=0 &&  screen[sp] <= ' ' ) {

			if (x - sp > numPref || screen[sp] == suff||
					screen[sp] == '.' ||
					screen[sp] == '*') {
				hs =false;
				break;
			}
		}

		// now lets check for how long the option is it has to be numPref or less
		os = sp;
		while (hs && --os > 0 && screen[os] > ' ' ) {

			if (sp - os >= numPref || screen[os] == suff ||
					screen[os] == '.' ||
					screen[os] == '*') {
				hs = false;
				break;
			}
		}
		if (sp - os > 1 && !Character.isDigit(screen[os+1])) {
			hs = false;
		}

		sp = x;

		if (Character.isDigit(screen[sp+1]))
			hs = false;
		// now lets make sure there are no more than numSuff spaces after option
		while (hs && (++sp < lenScreen && screen[sp] <= ' '
			|| screen[sp] == suff )) {
			if (sp - x >= numSuff || screen[sp] == suff ||
					screen[sp] == '.' ||
					screen[sp] == '*') {
				hs =false;
				break;
			}
		}
		if (hs && !Character.isLetterOrDigit(screen[sp]))
			hs = false;
		if (hs) {
			return os;
		}
		return -1;
	}

}