module Sbuilder

  class ParamSet < ParamSetRoot

    # attr_reader :parameters                   # array of parameters:Parameter

    # ------------------------------------------------------------------
    # mixer
    PROGNAME = nil                            # progname for logger default class name
    include Sbuilder::Utils::MyLogger         # mix logger


    # ------------------------------------------------------------------
    # constrcutore
    def initialize( options = {} )
      super( options )
      @logger = getLogger( PROGNAME, options )
      @logger.debug( "#{__method__} initialized" )
      # @parameters = []
    end

    def to_s
      "#{getId}"
    end

    # normally resolve 'parameter' sub-classes may override ie. to
    # include also response parameters to the list of parameters to
    # resolve.
    def parametersToResolve
      parameters
    end

    # @return [Boolean] true is some of of 'parametersToResolve'
    # unsersolved. Uses 'resolveReference' to resolve a parameter, if
    # parameter implements this method.
    def resolveNeeded( controller )
      # TODO - check parametersToResolve
      # return true
      unresolved = parametersToResolve.select { |p| !( p.isResolved || p.respond_to?(:resolveReference) && p.resolveReference(controller.model))  }
      needed = unresolved.any?
      @logger.debug "#{__method__}: #{getId} resolve needed=#{needed},  unresolved=#{unresolved.map {|u| u.name}.join(',')}, parametersToResolve=#{parametersToResolve.map{|p| p.name }.join(',')}" if @logger.debug?
      needed
    end

    # ------------------------------------------------------------------
    # builder
    # def addParameter( param )
    #   parameters << param
    #   self
    # end

    # identifier for finding domain matche
    
    def matchesWithParamSet( matcher )
      matcher.is_a?( String ) ? getId == matcher  : (getId =~ matcher) != nil
    end

    def getId
      doGetId
    end
    

    def doGetId
      msg = "Sub class should implement doGetId -method"
      @logger.error( "#{__method__} #{msg}" )
      return msg
      # raise NoMethodError.new( msg  )
    end

    # ------------------------------------------------------------------
    # generata phase

    
    # return hash for generation phase, false if no paramteers
    def parameter_definitions( model, paramArray=parameters )
      arra = paramArray.map.with_index do |p,i|
        # puts "p=#{p}"
        parameter_def = p.parameter_definition( model )
        # puts "parameter_def=#{parameter_def}"
        parameter_def[:parameter_name] = ParamSet.cleanUpName( parameter_def[:parameter_name] )
        
        parameter_def['_comma'] = (i < paramArray.length-1 ? "," : "" )   # empty string for last element
        parameter_def
        # {
        #   :name           => p.name,
        #   :parameter_name => ParamSet.cleanUpName( p.name ),
        #   :type           => p.getType,
        #   :
        # }
      end
      # return false if no parameter
      return false if arra.length == 0
      return arra
    end

    # make it valid identifier 
    def self.cleanUpName( name )
      return name ?
               name.gsub( /\./, "_" ) :    # . --> _
               name
    end

    # getId with invalid-caharacters as underscpce
    def getName
      self.class.id2name(getId)
      # return getId.
      #         gsub( /\//, "_" ).   # / --> _
      #         gsub( /\(/, "_" ).   # ( --> _
      #         gsub( /\{/, "_" ).   # { --> _
      #         gsub( /\}/, "_" ).   # } --> _
      #         gsub( /\./, "_" ).   # . --> _              
      #         gsub( /\)/, "_" )    # ) --> _
      
    end

    # ------------------------------------------------------------------
    # locateParameter

    # Locate parameter 'key', raise on an error if not found
    def locateParameter( key )
      key = key.first if key.is_a?( Array )
      @logger.debug( "#{__method__} key=#{key}" )


      # locate key in this paramter set
      # puts "parameters=#{parameters}"
      found = parameters.select do |parameter|
        # puts "parameter.name #{parameter.name} == key = #{key}"
        parameter.name == key
      end.first
      @logger.debug( "#{__method__} key=#{key} --> found='#{found}' found.class=#{found.class}" )
      raise <<-EOS if found.nil?

      Could not locate parameter '#{key}' in parameter set '#{getId}'

      Valid names in parameter set '#{getId}':  #{parameters.map {|parameter| parameter.name}.join(',')}

      EOS
      
      return found

    end

   
    
  end # class
  
end