/*
    * Copyright (c) 2001-2004,
    * RedVerst Group, ISP RAS http://www.ispras.ru
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    *
    * 1. Redistributions of source code must retain the above copyright notice, this
   *    list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   *    this list of conditions and the following disclaimer in the documentation
   *    and/or other materials provided with the distribution.
   *
   * 3. The names "ATP", "TreeDL", "RedVerst", "ISP RAS"
   *    may not be used to endorse or promote products derived from this software
   *    without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
   * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
   * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  
  package com.unitesk.atp.text.generation;
  
  //==============================================================================
  
  import java.util.HashMap;
  import java.util.Map;
  
  import com.unitesk.atp.dynattrs.Accessor;
  import com.unitesk.atp.dynattrs.Attributed;
  import com.unitesk.atp.dynattrs.MapAttributed;
  import com.unitesk.atp.text.filters.PatternFilter;
  import com.unitesk.atp.text.filters.TextReceiver;
  
  //==============================================================================
  
  /***
   * The basic implementation of {@link Generator} interface.
   * Processed text is passed to client {@link TextReceiver text receiver}.
   *
   * @author <A href="mailto:demakov@ispras.ru">Alexey Demakov</A>
   * @version $Id: BasicGenerator.java,v 1.2 2004/10/11 15:51:32 all-x Exp $
   */
  public class BasicGenerator
      implements Generator, PatternFilter.ParameterProcessor
  {
      //--------------------------------------------------------------------------
      // constructors
  
      /***
       * Constructs generator with the specified client.
       *
       * @param  client  The client text receiver.
       */
      public BasicGenerator( TextReceiver client )
      {
          this( client, new DefaultFunction(), "${", "}" );
      }
  
      /***
       * Constructs generator with the specified parameters.
       *
       * @param  client  The client text receiver.
       * @param  default_func
       *                 The default function
       * @param  par_start
       *                 The parameter start delimemter
       * @throws  NullPointerException     If client == null
       */
      public BasicGenerator( TextReceiver client
                           , Function default_func
                           , String par_start
                           , String par_end
                           )
      {
          if( client == null )
          {
              throw new NullPointerException();
          }
  
          this.client = client;
  
          pattern_filter = new PatternFilter( client, this, par_start, par_end );
  
          setFunction( DEFAULT_NAME, default_func );
      }
  
      //--------------------------------------------------------------------------
      // interface Generator
 
     /***
      * {@inheritDoc}
      */
     public Function setFunction( String name, Function func )
     {
         mustBeID( name );
 
         Function res;
 
         if( func != null )
         {
             func.setGenerator( this );
             res = (Function)name_to_func.put( name, func );
         } else {
             res = (Function)name_to_func.remove( name );
         }
         if( res != null && res != func )
         {
             /*
              * free function
              */
             res.setGenerator( null );
         }
         return res;
     }
 
     /***
      * {@inheritDoc}
      */
     public Function getFunction( String name )
     {
         mustBeID( name );
 
         return (Function)name_to_func.get( name );
     }
 
     /***
      * {@inheritDoc}
      */
     public Object setVariable( String name, Object var )
     {
         mustBeID( name );
 
         if( var != null )
         {
             return name_to_var.put( name, var );
         } else {
             return name_to_var.remove( name );
         }
     }
 
     /***
      * {@inheritDoc}
      */
     public Object getVariable( String name )
     {
         mustBeID( name );
 
         return name_to_var.get( name );
     }
 
     /***
      * {@inheritDoc}
      */
     public void txt( String str )
     {
         pattern_filter.txt( str );
     }
 
     /***
      * {@inheritDoc}
      */
     public void txtAsIs( String str )
     {
         client.txt( str );
     }
 
     //--------------------------------------------------------------------------
     // interface PatternFilter.ParameterProcessor
 
     /***
      * {@inheritDoc}
      */
     public void param( String param )
     {
         int colon = param.indexOf( ':' );
 
         String func;
         int arg_pos;
 
         if( colon == -1 )
         {
             func = DEFAULT_NAME;
             arg_pos = 0;
         } else {
             func = param.substring( 0, colon );
             arg_pos = colon + 1;
         }
 
         Function f;
         try
         {
             f = getFunction( func );
         }
         catch( IllegalArgumentException e )
         {
             f = null;
         }
 
         if( f == null )
         {
             throw new UndefinedFunctionException( param, func );
         }
 
         Object var_obj;
 
         int param_len = param.length();
         if( arg_pos < param_len && param.charAt( arg_pos ) == '.' )
         {
             /*
              * 'absolute' path starts from variable name.
              * get it from variable map
              */
             var_obj = variable_map;
             arg_pos++;
         } else {
             // use default variable
             var_obj = getVariable( DEFAULT_NAME );
         }
 
         Object arg_obj;
 
         if( arg_pos == param_len )
         {
             arg_obj = var_obj;
         } else {
             int question = param.indexOf( "?", arg_pos );
             String arg;
 
             if( question != -1 )
             {
                 arg = param.substring( arg_pos, question );
             } else {
                 arg = param.substring( arg_pos );
             }
 
             arg_obj = Accessor.getAttribute( var_obj
                                            , arg
                                            , variable_map
                                            );
 
             if( arg_obj == null && question != -1 )
             {
                 arg_obj = param.substring( question + 1 );
             }
         }
 
         f.process( arg_obj );
     }
 
     //--------------------------------------------------------------------------
     // implementation
 
     protected void mustBeID( String id )
     {
         if( id.length() > 0 && !Accessor.isID( id ) )
         {
            throw new IllegalArgumentException( id );
         }
     }
 
     protected Map/*String,Function*/ name_to_func
         = new HashMap/*String,Function*/();
 
     protected Map/*String,Object*/ name_to_var
         = new HashMap/*String,Object*/();
 
     protected Attributed variable_map = new MapAttributed( name_to_var );
 
     protected PatternFilter pattern_filter;
 
     protected TextReceiver client;
 }