/**
 * Title: tn5250J
 * 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.CMD_READ_INPUT_FIELDS;
import static org.tn5250j.TN5250jConstants.CMD_READ_MDT_FIELDS;
import static org.tn5250j.TN5250jConstants.CMD_READ_MDT_IMMEDIATE_ALT;

import java.io.ByteArrayOutputStream;

import org.tn5250j.encoding.ICodePage;

public class ScreenFields {

   private ScreenField[] screenFields;
   private ScreenField currentField;
   private ScreenField saveCurrent;
   private int sizeFields;
   private boolean cpfExists;
   private int nextField;
   private int fieldIds;
   private Screen5250 screen;
   private boolean masterMDT;
   protected boolean currentModified;

   public ScreenFields(Screen5250 s) {

      screen = s;
      screenFields = new ScreenField[256];
   }

   protected void clearFFT() {

      sizeFields = nextField = fieldIds = 0;
      cpfExists = false;   // clear the cursor progression fields flag
      currentField = null;
      masterMDT = false;

   }

   protected boolean existsAtPos(int lastPos) {

      ScreenField sf = null;

      // from 14.6.12 for Start of Field Order 5940 function manual
      //  examine the format table for an entry that begins at the current
      //  starting address plus 1.
      for (int x = 0;x < sizeFields; x++) {
         sf = screenFields[x];

         if (lastPos == sf.startPos()) {
            currentField = sf;
            currentModified = false;
            return true;
         }

      }

      return false;
   }

   public boolean isMasterMDT() {
      return masterMDT;
   }

   protected void setMasterMDT() {
      masterMDT = true;
   }

   public boolean isCurrentField() {
      return currentField == null;
   }

   public boolean isCurrentFieldFER() {
      return currentField.isFER();
   }

   public boolean isCurrentFieldDupEnabled() {
      return currentField.isDupEnabled();
   }

   public boolean isCurrentFieldToUpper() {
      return currentField.isToUpper();
   }

   public boolean isCurrentFieldBypassField() {
      return currentField.isBypassField();
   }

   public boolean isCurrentFieldHighlightedEntry() {
      if (currentField != null)
         return currentField.isHiglightedEntry();
      else
         return false;
   }

   public boolean isCurrentFieldAutoEnter() {
      return currentField.isAutoEnter();
   }

   public boolean withinCurrentField(int pos) {
      return currentField.withinField(pos);
   }

   public boolean isCurrentFieldContinued() {
      return currentField.isContinued();
   }

   public boolean isCurrentFieldContinuedFirst() {
      return currentField.isContinuedFirst();
   }

   public boolean isCurrentFieldContinuedMiddle() {
      return currentField.isContinuedMiddle();
   }

   public boolean isCurrentFieldContinuedLast() {
      return currentField.isContinuedLast();
   }

   public boolean isCurrentFieldModified() {
      return currentModified;
   }

   /**
    * This routine is used to check if we can send the Aid key to the host
    *
    * Taken from Section  16.2.1.2 Enter/Rec Adv Key
    *
    * In the normal unlocked state, when the workstation operator presses the
    * Enter/Rec Adv key:
    *
    * 1. The 5494 checks for the completion of mandatory-fill, self-check, and
    *    right-adjust fields when in an active field. (An active field is one in
    *    which the workstation operator has begun entering data.) If the
    *    requirements of the field have not been satisfied, an error occurs.
    *
    * @return
    *
    */
   public boolean isCanSendAid() {

      // We also have to check if we are still in the field.
      if (currentField != null &&
            (currentField.getAdjustment() > 0 || currentField.isSignedNumeric())
             && currentModified && isInField()
            && !currentField.isCanSend())

         return false;
      else
         return true;

   }

   protected void saveCurrentField() {
      saveCurrent = currentField;
   }

   protected void restoreCurrentField() {
      currentField = saveCurrent;
   }

   protected void setCurrentField(ScreenField sf) {
      currentField = sf;
   }

   protected void setCurrentFieldMDT() {
      currentField.setMDT();
      currentModified = true;
      masterMDT = true;
   }

   protected void setCurrentFieldFFWs(int ffw1, int ffw2) {

      masterMDT = currentField.setFFWs(ffw1,ffw2);

   }


   protected ScreenField setField(int attr, int row, int col, int len, int ffw1,
                           int ffw2, int fcw1, int fcw2) {

      ScreenField sf = null;
      screenFields[nextField] = new ScreenField(screen);
      screenFields[nextField].setField(attr,row,col,len,ffw1,ffw2,fcw1,fcw2);
      sf = screenFields[nextField++];

      sizeFields++;


      // set the field id if it is not a bypass field
      // this is used for cursor progression
      //  changed this because of problems not allocating field id's for
      //  all fields.  kjp 2002/10/21
//      if (!sf.isBypassField())
      sf.setFieldId(++fieldIds);

      // check if the cursor progression field flag should be set.
//      if ((fcw1 & 0x88) == 0x88)
      if (fcw1 == 0x88)
         cpfExists = true;

      if (currentField != null) {
         currentField.next = sf;
         sf.prev = currentField;
      }

      currentField = sf;

      // check if the Modified Data Tag was set while creating the field
      if (!masterMDT)
         masterMDT = currentField.mdt;

      currentModified = false;

      return currentField;

   }

   public ScreenField getField(int index) {

      return screenFields[index];
   }

   public ScreenField getCurrentField() {
      return currentField;
   }

   public int getCurrentFieldPos() {
      return currentField.getCurrentPos();
   }

   protected int getCurrentFieldShift() {
      return currentField.getFieldShift();
   }

   public String getCurrentFieldText() {

      return currentField.getText();
   }

   public int getCurrentFieldHighlightedAttr(){
      return currentField.getHighlightedAttr();
   }

   public int getSize() {

      return sizeFields;
   }

   public int getFieldCount() {

      return sizeFields;
   }

   protected boolean isInField(int pos) {
      return isInField(pos,true);
   }

   protected boolean isInField() {
      return isInField(screen.getLastPos(),true);
   }

   protected boolean isInField(int pos, boolean chgToField) {

      ScreenField sf;

      for (int x = 0;x < sizeFields; x++) {
         sf = screenFields[x];

         if (sf.withinField(pos)) {

            if (chgToField) {
               if (!currentField.equals(sf))
                  currentModified = false;
               currentField = sf;
            }
            return true;
         }
      }
      return false;

   }

   /**
    * Searches the collection for the target string and returns the iOhioField
    * object containing that string.  The string must be totally contained
    * within the field to be considered a match.
    *
    * @param targetString The target string.
    * @param startPos The row and column where to start the search. The position
    *                 is inclusive (for example, row 1, col 1 means that
    *                 position 1,1 will be used as the starting location and
    *                 1,1 will be included in the search).
    * @param length The length from startPos to include in the search.
    * @param dir An OHIO_DIRECTION value:
    *
    * <table BORDER COLS=3 WIDTH="50%" >
    * <tr><th>Constant </th><th>Value</th>
    *                            <th>Description</th></tr>
    * <tr><td>OS_OHIO_DIRECTION_FORWARD </td><td>0</td>
    *                            <td>Forward (beginning towards end)</td></tr>
    * <tr><td>OS_OHIO_DIRECTION_BACKWARD </td><td>1</td>
    *                            <td>Backward (end towards beginning)</td></tr>
    * </table>
    *       Constant Value Description
    *       ignoreCase - Indicates whether the search is case sensitive.
    *       True means that case will be ignored. False means the search will
    *       be case sensitive.
    * @return If found, an iOhioField object containing the target string. If
    *         not found, returns a null.
    */
   public ScreenField findByString (String targetString,
                                             int startPos,
                                             int length,
                                             int dir,
                                             boolean ignoreCase) {

      // first lets check if the string exists in the screen space
//      iOhioPosition pos = screen.findString(targetString, startPos, length,
//                                             dir, ignoreCase);

      // if it does exist then lets search the fields by the position that
      //  was found and return the results of that search.
//      if (pos != null) {
         return findByPosition(startPos);
//      }

      //return null;

   }

   /**
    * Searches the collection for the target position and returns the ScreenField
    * object containing that position.
    *
    * @param targetPosition The target row and column expressed as a linear
    *          position within the presentation space.
    *
    * @return If found, a ScreenField object containing the target position.
    *         If not found, returns a null.
    */
   public ScreenField findByPosition(int targetPosition) {

      ScreenField sf = null;

      for (int x = 0;x < sizeFields; x++) {

         sf = screenFields[x];

         if (sf.withinField(targetPosition)) {
            return sf;
         }

      }

      return null;
   }

   /**
    * Searches the collection for the target position and returns the ScreenField
    * object containing that position.
    *
    * @param row The beginning row to start search with in the presentation space.
    * @param col The beginning column to start search with in the presentation space.
    *
    * @return If found, a ScreenField object containing the target position.
    *         If not found, returns a null.
    */
   public ScreenField findByPosition(int row, int col) {

      return findByPosition(screen.getPos(row,col));
   }

   public ScreenField[] getFields () {

      ScreenField[] fields = new ScreenField[sizeFields];
      for (int x = 0; x < sizeFields; x++) {

         fields[x] = screenFields[x];
      }

      return fields;
   }

   public ScreenField getFirstInputField() {

		if (sizeFields <= 0)
			return null;

      int f = 0;
      ScreenField sf = screenFields[f];

      while (sf.isBypassField() && f++ < sizeFields) {
         sf = screenFields[f];
      }

      if (sf.isBypassField())
         return null;
      else
         return sf;

   }

   public void gotoFieldNext() {

      // sanity check - we were getting null pointers after a restore of screen
      //   and cursor was not positioned on a field when returned
      //   *** Note *** to myself
      //   maybe this is fixed I will have to check this some time
      int lastPos = screen.getLastPos();

      if (currentField == null && (sizeFields != 0) && !isInField(lastPos,true)) {
         int pos = lastPos;
         screen.setCursorOff();
         screen.advancePos();
         lastPos = screen.getLastPos();
         while (!isInField() && pos != lastPos) {
            screen.advancePos();
         }
         screen.setCursorOn();
      }

      // if we are still null do nothing
      if (currentField == null)
         return;

      ScreenField sf = currentField;

      if (!sf.withinField(lastPos)) {
         screen.setCursorOff();

         if (sizeFields > 0) {

            // lets get the current position so we can test if we have looped
            //    the screen and not found a valid field.
            int pos = lastPos;
            int savPos = lastPos;
            boolean done = false;
            do {
               screen.advancePos();
               lastPos = screen.getLastPos();
               if (isInField(lastPos)
                   || pos==lastPos) {
                  if (!currentField.isBypassField()) {
                     screen.gotoField(currentField);
                     done = true;
                  }
               }
            }  while ( !done && lastPos != savPos);
         }
         currentModified = false;
         screen.setCursorOn();

      }
      else {
         if (!cpfExists) {
            do {

               sf = sf.next;
            }
            while ( sf != null && sf.isBypassField());

         }
         else {
            int f = 0;
            int cp = sf.getCursorProgression();

            if (cp == 0) {
               do {

                  sf = sf.next;
               }
               while ( sf != null && sf.isBypassField());

            }
            else {
               ScreenField sf1 = null;
               boolean found = false;
               while (!found && f < sizeFields) {

                  sf1 = screenFields[f++];
                  if (sf1.getFieldId() == cp)
                     found = true;
               }
               if (found)
                  sf = sf1;
               else {
                  do {
                     sf = sf.next;
                  }
                  while ( sf != null && sf.isBypassField());

               }
               sf1 = null;
            }
         }
         if (sf == null)
            screen.gotoField(1);
         else {
            currentField = sf;
            screen.gotoField(currentField);
         }

         currentModified = false;

      }
   }

   public void gotoFieldPrev() {

      ScreenField sf = currentField;
      int lastPos = screen.getLastPos();

      if (!sf.withinField(lastPos)) {
         screen.setCursorOff();

         if (sizeFields > 0) {
            // lets get the current position so we can test if we have looped
            //    the screen and not found a valid field.
            int pos = lastPos;
            int savPos = lastPos;
            boolean done = false;

            do {
               screen.changePos(-1);
               lastPos = screen.getLastPos();

               if (isInField(lastPos)
                  || (pos == lastPos)) {

                  if (!currentField.isBypassField()) {
                     screen.gotoField(currentField);
                     done = true;
                  }
               }
            } while ( !done && lastPos != savPos);
         }
         screen.setCursorOn();

      }
      else {

         if (sf.startPos() == lastPos) {
            if (!cpfExists) {

               do {
                  sf = sf.prev;
               }
               while ( sf != null && sf.isBypassField());
            }
            else {

               int f = 0;
               int cp = sf.getFieldId();
               ScreenField sf1 = null;
               boolean found = false;
               while (!found && f < sizeFields) {

                  sf1 = screenFields[f++];
                  if (sf1.getCursorProgression() == cp)
                     found = true;
               }
               if (found)
                  sf = sf1;
               else {
                  do {
                     sf = sf.prev;
                  }
                  while ( sf != null && sf.isBypassField());
               }
               sf1 = null;
            }
         }

         if (sf == null) {
            int size = sizeFields;
            sf = screenFields[size - 1];

            while (sf.isBypassField() && size-- > 0) {
               sf = screenFields[size];

            }
         }
         currentField = sf;
         currentModified = false;
         screen.gotoField(currentField);
      }
   }

   protected void readFormatTable(ByteArrayOutputStream baosp,int readType, ICodePage codePage) {

      ScreenField sf;
      boolean isSigned = false;
      char c;

      if (masterMDT) {

         StringBuffer sb = new StringBuffer();
         for (int x = 0; x < sizeFields; x++) {
            isSigned = false;

            sf = screenFields[x];

            if (sf.mdt || (readType == CMD_READ_INPUT_FIELDS)) {

               sb.setLength(0);
               sb.append(sf.getText());


               if (readType == CMD_READ_MDT_FIELDS ||
                     readType == CMD_READ_MDT_IMMEDIATE_ALT) {
                  int len = sb.length() - 1;

                  // we strip out all '\u0020' and less
                  while (len >= 0 &&
//                     (sb.charAt(len) <= ' ' || sb.charAt(len) >= '\uff20' )) {
                     (sb.charAt(len) < ' ' || sb.charAt(len) >= '\uff20')) {

                     // if we have the dup character and dup is enabled then we
                     //    stop here
                     if (sb.charAt(len) == 0x1C && sf.isDupEnabled())
                        break;

                     sb.deleteCharAt(len--);
                  }

               }

//               System.out.println("field " + sf.toString());
//               System.out.println(">" + sb.toString() + "<");
//               System.out.println(" field is all nulls");
               if (sf.isSignedNumeric() && sb.length() > 0 && sb.charAt(sb.length() - 1) == '-') {
                  isSigned = true;
                  sb.setLength(sb.length() - 1);
               }

               int len3 = sb.length();

               if (len3 > 0 || (readType == CMD_READ_MDT_FIELDS ||
                       readType == CMD_READ_MDT_IMMEDIATE_ALT)) {

                  if ((readType == CMD_READ_MDT_FIELDS ||
                       readType == CMD_READ_MDT_IMMEDIATE_ALT)) {

                     baosp.write(17);   // start of field data
                  if (sf.isSelectionField()) {
                     baosp.write(screen.getRow(sf.selectionPos)+1);
                     baosp.write(screen.getCol(sf.selectionPos)+1);
                  }
                  else {
                     baosp.write(sf.startRow()+1);
                     baosp.write(sf.startCol()+1);
                  }

                  }
//                  int len = sb.length();
                  if (sf.isSelectionField()) {
                     baosp.write(0);
                     baosp.write(sf.selectionIndex + 0x1F);

                  }
                  else {
                  for (int k = 0; k < len3; k++) {
                     c = sb.charAt(k);
                     // here we have to check for special instances of the
                     //    characters in the string field.  Attribute bytes
                     //    are encoded with an offset of \uff00
                     //    This is a hack !!!!!!!!!!!
                     //    See ScreenField object for a description
                     if (c < ' ' || c >= '\uff20') {

                        // if it is an offset attribute byte we just pass
                        //    it straight on to the output stream
                        if (c >= '\uff20' && c <= '\uff3f') {
                           baosp.write(c - '\uff00');
                        }
                        else
                           // check for dup character
                           if (c == 0x1C)
                              baosp.write(c);
                           else
                              baosp.write(codePage.uni2ebcdic(' '));
                     }
                     else {
                        if (isSigned && k == len3 - 1) {
                           baosp.write(0xd0 | (0x0f & c));
                        }
                        else
                           baosp.write(codePage.uni2ebcdic(c));

                     }
                  }
                  }
               }
            }
         }
      }
   }

}