/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of Java-Common.
    *
    * Java-Common 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.
   *
   * Java-Common 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 Java-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.application.state.impl;
  
  import com.cosylab.application.state.*;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStream;
  import java.io.PrintWriter;
  
  import java.util.Iterator;
  
  
  /**
   * This class is an implementation of the <code>StateStorage</code> that uses
   * simple text file to store the array of the <code>State</code> objects.
   * Stored file is the plain <code>java.util.Properties</code> file format with
   * the few 'weird' properties added which are used for fast hierarchy
   * resolving.
   *
   * @author dvitas
   */
  public class TextStateStorage extends DefaultStateStorage {
      protected final static String stateStart = "<State>";
      protected final static String stateEnd = "<EndState>";
      protected final static String childDelimiter = "<Child>";
  
      /**
                       *
                       */
      public TextStateStorage() {
          super();
      }
  
      /**
       * Creates a new TextStateStorage object.
       *
       * @param ss DOCUMENT ME!
       */
      public TextStateStorage(StateStorage ss) {
          super(ss);
      }
  
      private void readState(BufferedReader br, State state)
          throws IOException {
          String line;
  
          while (true) {
              line = br.readLine();
  
              if (line == null) {
                  break;
              }
  
              line = line.trim();
  
              if (line.startsWith(stateEnd)) {
                  break;
              }
  
              if (line.startsWith(childDelimiter)) {
                  String childKey = line.substring(childDelimiter.length());
                  State s = state.createState(childKey);
                  br.readLine(); // eat state header
                  readState(br, s);
  
                  continue;
              }
  
              int index = line.indexOf('=');
              String key = line.substring(0, index);
              String value = line.substring(index + 1);
              state.putString(key, value);
          }
      }
  
      /* (non-Javadoc)
       * @see com.cosylab.application.state.StateStorage#load(java.io.InputStream)
       */
     public void load(String filePath, String applicationName)
         throws IOException {
         if (delegate != null) {
             delegate.load(filePath, applicationName);
             addAll(delegate.getStates());
 
             return;
         }
 
         // get the InputStream if file exists
         InputStream is = getInputStream(filePath, applicationName + ".txt");
         load(is);
     }
 
     /* (non-Javadoc)
 	 * @see com.cosylab.application.state.StateStorage#load(java.io.InputStream)
 	 */
 	public void load(InputStream is) throws IOException {
 		if (is == null) {
 			return;
 		}
 
 		BufferedReader br = new BufferedReader(new InputStreamReader(is));
 		String line;
 
 		while (true) {
 			line = br.readLine();
 
 			if (line == null) {
 				break;
 			}
 
 			line = line.trim();
 
 			if (line.startsWith(stateStart)) {
 				State state = StateFactory.createState();
 				readState(br, state);
 				states.add(state);
 			}
 		}
 	}
     
     private void printIndent(PrintWriter pw, int indent) {
         for (int i = 0; i < indent; i++) {
             pw.print("  ");
         }
     }
 
     private void print(PrintWriter pw, State s, int indent) {
         int i;
         Iterator iter = s.keySet().iterator();
         printIndent(pw, indent);
         pw.println(stateStart);
 
         while (iter.hasNext()) {
             String key = (String) iter.next();
             Object value = s.getObject(key);
 
             if (value instanceof State) {
                 printIndent(pw, indent + 1);
                 pw.println(childDelimiter + key);
                 print(pw, (State) value, indent + 1);
 
                 continue;
             }
 
             printIndent(pw, indent);
             pw.println(key + "=" + value.toString());
         }
 
         printIndent(pw, indent);
         pw.println(stateEnd);
     }
 
     /* (non-Javadoc)
      * @see com.cosylab.application.state.StateStorage#store(java.io.OutputStream)
      */
     public void store(String filePath, String applicationName)
         throws IOException {
         OutputStream os = getOutputStream(filePath, applicationName + ".txt");
         store(os);
     }
     
     /* (non-Javadoc)
 	 * @see com.cosylab.application.state.StateStorage#store(java.io.OutputStream, java.lang.String)
 	 */
 	public void store(OutputStream os) throws IOException {
 		if (os == null) {
 			return;
 		}
 
 		PrintWriter pw = new PrintWriter(os);
 
 		for (int i = 0; i < states.size(); i++) {
 			State s = (State) states.get(i);
 			print(pw, s, 0);
 		}
 
 		pw.flush();
 		pw.close();
 	}
 }
 
 
 /* __oOo__ */