/*
    * $Id: ZsciiString.java,v 1.4 2005/10/25 16:27:32 weiju Exp $
    * 
    * Created on 08.10.2005
    * Copyright 2005 by Wei-ju Wu
    *
    * This file is part of The Z-machine Preservation Project (ZMPP).
    *
    * ZMPP 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 of the License, or
   * (at your option) any later version.
   *
   * ZMPP 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 ZMPP; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
   */
  package org.zmpp.vmutil;
  
  import java.util.ArrayList;
  import java.util.List;
  
  import org.zmpp.base.DefaultMemoryAccess;
  import org.zmpp.base.MemoryAccess;
  import org.zmpp.base.MemoryReadAccess;
  
  /***
   * This class represents a string of Z characters. It also does some
   * conversion in case a string is specified as a constructor argument. 
   * 
   * @author Wei-ju Wu
   * @version 1.0
   */
  public class ZsciiString {
  
    private MemoryReadAccess memaccess;
    private int startAddress;
    private byte[] buffer;
    private static ZsciiConverter decoder;
    
    static {
      
      decoder = new ZsciiConverter(3, null);
    }
  
    /***
     * Constructor. Creates a ZsciiString from a string.
     * 
     * @param str a Java string object
     */
    public ZsciiString(String str) {
      
      encode(str);
    }
    
    /***
     * Sets the converter object used by the ZsciiString class.
     * 
     * @param converter the converter
     */
    public static void setZsciiConverter(ZsciiConverter converter) {
      
      decoder = converter;
    }
   
    /***
     * Constructor. Creates a ZsciiString sharing data that lies at the
     * specified position in memory.
     * 
     * @param memaccess a memory access object
     * @param startAddress the start address within the memory access object
     */
    public ZsciiString(MemoryReadAccess memaccess, int startAddress) {
      
      this.memaccess = memaccess;
      this.startAddress = startAddress;
    }
  
    /***
     * Creates a ZsciiString from a single zchar.
     * 
     * @param zchar a ZSCII char
     */
    public ZsciiString(short zchar) {
      
      byte[] buffer = new byte[2];
      MemoryAccess memaccess = new DefaultMemoryAccess(buffer);
      int zword = 0x80a5; // 1 00000 00101 00101
      zword |= ((zchar & 0x1f) << 10);
      memaccess.writeUnsignedShort(0, zword);
      this.memaccess = memaccess;
    }
    
    /***
    * Returns a memory access object.
    * 
    * @return the memory access object
    */
   public MemoryReadAccess getMemoryAccess() {
     
     return memaccess;
   }
   
   /***
    * Returns the start address within the memory access buffer.
    * 
    * @return the start address in the memory access object
    */
   public int getStartAddress() {
     
     return startAddress;
   }
   
   /***
    * Encodes the specified String object to a ZSCII string.
    * 
    * @param str the string
    */
   private void encode(String str) {
     
     List<Integer> result = new ArrayList<Integer>();
     char c; // the current character 
     int zwpos = 0; // the character position within a zword
     int zword = 0; // the current zword
     
     for (int i = 0; i < str.length(); i++) {
       
       c = str.charAt(i);
       if (needsShift(c)) {
       
         short zchar = getShiftFor(c);
         // put character in correct position
         zword |= (zchar << ((2 - zwpos) * 5));
         zwpos++;
       }
       
       // new zword needed
       if (zwpos > 2) {
         
         result.add(zword);
         zword = 0;
         zwpos = 0;
       }
       
       short zchar = getZchar(c);
       zword |= (zchar << ((2 - zwpos) * 5));
       zwpos++;
       
       // end of string ? mark the current zword as last then
       if (i == str.length() - 1) {
         
         zword |= 0x8000;
       }
       
       // pad with 0x05's if necessary
       if ((zword & 0x8000) > 0) {
         
         for (; zwpos < 3; zwpos++) {
           
           zword |= (0x05 << ((2 - zwpos) * 5));
         }
       }
       
       // new zword needed
       if (zwpos > 2) {
         
         result.add(zword);
         zword = 0;
         zwpos = 0;
       }      
     }
     int numWords = result.size();
     buffer = new byte[numWords * 2];
     MemoryAccess memaccess = new DefaultMemoryAccess(buffer);
     for (int i = 0; i < numWords; i++) {
       
       memaccess.writeUnsignedShort(i * 2, result.get(i));
     }
     this.memaccess = memaccess;
   }
   
   /***
    * Returns the ZSCII representation of the specified character.
    * 
    * @param c a Java character
    * @return the ZSCII character
    */
   private short getZchar(char c) {
     
     if (c >= 'A' && c <= 'Z') return (short) ((c - 'A') + 6); 
     if (c >= 'a' && c <= 'z') return (short) ((c - 'a') + 6);
     if (c == ' ') return 0;
     for (int i = 1; i < ZsciiConverter.A2CHARS.length(); i++) {
       
       if (ZsciiConverter.A2CHARS.charAt(i) == c) return (short) (i + 6);
     }
     return (short) c;
   }
   
   /***
    * Returns the total number of Zwords occupied by this ZsciiString.
    * 
    * @return the numbe of 16-bit words
    */
   public int getNumWords() {
     
     int zword = 0;
     
     for (int i = 0; ; i++) {
       
       zword = memaccess.readUnsignedShort(startAddress + i * 2);
       if ((zword & 0x8000) > 0) return (i + 1);
     }
   }
   
   /***
    * {@inheritDoc}
    */
   public boolean equals(Object o) {
     
     if (o == this) return true;
     if (o != null && o instanceof ZsciiString) {
       
       return o.toString().equals(toString());
     }
     return false;
   }
   
   /***
    * {@inheritDoc}
    */
   public String toString() {
     
     return decoder.convert(memaccess, startAddress);
   }
   
   /***
    * Returns true, if the specified character needs a shift to be encoded.
    * 
    * @param c a Java character
    * @return true, if needs shift character, false, else
    */
   private boolean needsShift(char c) {
     
     if (c >= 'A' && c <= 'Z') return true;
     
     for (int i = 0; i < ZsciiConverter.A2CHARS.length(); i++) {
       
       if (ZsciiConverter.A2CHARS.charAt(i) == c) return true;
     }
     return false;
   }
   
   /***
    * Returns the shift character needed to be properly encoded.
    * 
    * @param c the Java character
    * @return the shift to select the proper alphabet
    */
   private short getShiftFor(char c) {
     
     if (c >= 'A' && c <= 'Z') return ZsciiConverter.SHIFT_4;
     else return ZsciiConverter.SHIFT_5;
   }
 }