/*
    * Copyright 2008 ATG Import Service Project
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * 
    *   http://www.apache.org/licenses/LICENSE-2.0
    * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package atg.adapter.gsa.xml;
  
  // Import Files.
  
  import java.io.*;
  import java.util.*;
  
  import org.xml.sax.*;
  import org.xml.sax.helpers.*;
  
  import atg.adapter.gsa.xml.TemplateParser;
  import atg.xml.XMLFileEntityResolver;
  import atg.epub.ImportService;
  
  import javax.xml.parsers.*;
  
  /***
   * ImportFileParser
   *
   * File parser for startSQLRepository formatted files.
   *
   */
  
  public class ImportFileParser extends DefaultHandler implements ContentHandler, ErrorHandler
  {
    private int mPhase;
    private File mImportFile;
    private SAXParser mParser = null;
  
    private ArrayList<ImportItem> mImportItemsArrayList = null;
    private int mAction;
    private String mItemDescriptor = null;
    private String mItemId = null;
    private String mRepositoryName = null;
    private Stack<String> mTagNames = new Stack<String>();
    private StringBuffer mPropertyValue = null;
    private HashMap<String, String> mProperties = null;
    private String mPropertyName = null;
  
    /***
     * Construct a new import file parser.
     */
  
    public ImportFileParser (int pPhase, File pImportFile)
    {
      mPhase = pPhase;
      mImportFile = pImportFile;
    }
    
    public ImportItem[] parseFile ()
    {
      // Variable declarations.
  
      SAXParserFactory factory = null;
      XMLReader reader = null;
      ImportItem[] importItems = null;
  
      // Create parser.
  
      try
      {
        factory = SAXParserFactory.newInstance();
        mParser = factory.newSAXParser();
        reader = mParser.getXMLReader();
        reader.setEntityResolver(new XMLFileEntityResolver());
      }
      catch (ParserConfigurationException e)
      {
        System.out.println ("PARSER: ParserConfigurationException: " + e.getMessage());
        return (null);
      }
      catch (SAXException e)
      {
        System.out.println ("PARSER: SAXException: " + e.getMessage());
        return (null);
      }
  
      // Create an input source and parse the string.
  
      mImportItemsArrayList = new ArrayList<ImportItem>();
  
      try
      {
       mParser.parse(mImportFile, this);
     }
     catch (SAXException e)
     {
       System.out.println ("PARSER: SAXException: " + e.getMessage());
       return (null);
     }
     catch (IOException e)
     {
       System.out.println ("PARSER: IOException: " + e.getMessage());
       return (null);
     }
     
     // Create the array.
     
     importItems = new ImportItem[mImportItemsArrayList.size()];
     importItems = (ImportItem[]) mImportItemsArrayList.toArray(importItems);
 
     return (importItems);
   }
 
   // ----------------------------
   // ContentHandler implementation
   // ----------------------------
   
   public void startElement
   (
     String namespaceURI,
     String localName,
     String qname,
     Attributes pAttributes
   )
   {
     mTagNames.push (qname);
     
     if (TemplateParser.TAG_ADD_ITEM.equals (qname))
     {
       readTagAttributes(pAttributes);
       mAction = ImportItem.M_ACTION_ADD;
       mProperties = new HashMap<String, String>();
     }
     else if (TemplateParser.TAG_UPDATE_ITEM.equals (qname))
     {
       readTagAttributes(pAttributes);
       mAction = ImportItem.M_ACTION_UPDATE;
       mProperties = new HashMap<String, String>();
     }
     else if (TemplateParser.TAG_REMOVE_ITEM.equals(qname))
     {
       readTagAttributes(pAttributes);      
       mAction = ImportItem.M_ACTION_DELETE;
       mProperties = new HashMap<String, String>();
     }
     else if (TemplateParser.TAG_SET_PROPERTY.equals(qname))
     {
       String propertyName = pAttributes.getValue (TemplateParser.ATTR_NAME);
       mPropertyName = propertyName;
       mPropertyValue = new StringBuffer ();
     }
   }
 
   private void readTagAttributes(Attributes pAttributes)
   {
     mItemDescriptor = pAttributes.getValue (TemplateParser.ATTR_ITEM_DESCRIPTOR);
     mItemId = pAttributes.getValue (TemplateParser.ATTR_ID);
     mRepositoryName = pAttributes.getValue (TemplateParser.ATTR_REPOSITORY);
   }
 
   // ----------------------------
   /***
    * Reads characters between tags <foo>characters</foo> For
    * startSQLRepository, this is typically a property value Note that values
    * with a comma are actually multi values
    */
   public void characters(char[] chars, int start, int length)
   {
     if (TemplateParser.TAG_SET_PROPERTY.equals (mTagNames.peek()))
     {
       mPropertyValue.append (new String (chars, start, length));
     }
   }
 
   // -----------------------------
   /***
    * Called when a tag ends This method cleans up state between tags
    */
   
   public void endElement (String namespaceURI, String localName, String pQName)
   {
     if (TemplateParser.TAG_ADD_ITEM.equals(pQName))
     {
       if (mPhase != ImportService.PHASE_DELETE)
       {
         addImportItem ();
       }
     }
     else if (TemplateParser.TAG_UPDATE_ITEM.equals(pQName))
     {
       if (mPhase != ImportService.PHASE_DELETE)
       {
         addImportItem ();
       }
     }
     else if (TemplateParser.TAG_REMOVE_ITEM.equals(pQName))
     {
       if (mPhase == ImportService.PHASE_DELETE)
       {
         addImportItem ();
       }
     }
     else if (TemplateParser.TAG_SET_PROPERTY.equals(pQName))
     {
       mProperties.put (mPropertyName, mPropertyValue.toString());
       mPropertyName = null;
     }
 
     String last = mTagNames.pop();
   }
 
   // ----------------------------
   /***
    * Called when we start parsing this file
    */
   public void startDocument()
   {    
   }
 
   // ----------------------------
   /***
    * Called when we are done parsing this file
    */
   public void endDocument()
   {
   }
 
   private void addImportItem ()
   {
     ImportItem importItem = new ImportItem ();
     
     importItem.setAction (mAction);
     importItem.setItemDescriptor (mItemDescriptor);
     importItem.setItemId (mItemId);
     importItem.setRepositoryName (mRepositoryName);
     importItem.setProperties (mProperties);
     
     mImportItemsArrayList.add (importItem);
     
     //displayImportItem (importItem);
   }
   
   private void displayImportItem (ImportItem pImportItem)
   {
     String propertyName;
     String propertyValue;
     
     System.out.println ("PARSER: ITEM: Property: Item Id Value: " + pImportItem.getItemId());    
     System.out.println ("PARSER: ITEM: Property: Item Descriptor Value: " + pImportItem.getItemDescriptor());    
     System.out.println ("PARSER: ITEM: Property: Action Value: " + pImportItem.getAction());    
 
     HashMap properties = pImportItem.getProperties();
     Iterator iterator = properties.keySet().iterator();
     
     while (iterator.hasNext())
     {
       propertyName = (String) iterator.next();      
       propertyValue = (String) properties.get (propertyName);
 
       System.out.println ("PARSER: ITEM: Property: " + propertyName + " Value: " + propertyValue);    
     }    
   }
 
   // ----------------------------
   // ErrorHandler implementation
   // ----------------------------
   
   public void error (SAXParseException e)
   {
     System.out.println("ERROR: " + e.getMessage());
   }
 
   public void fatalError (SAXParseException e)
   {
     System.out.println("FATAL ERROR: " + e.getMessage());
   }
 
   public void warning(SAXParseException e)
   {
     System.out.println("WARNING: " + e.getMessage());
   }
 }