module Sbuilder

  class DomainType < Domain

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

    TYPE_DEFS = {
      'Int' => {
        :tlaBaseType => true,        
      },

      'BOOLEAN' => {
        :cardinality => 2,
        :domain_range => 0..1,
        :tlaBaseType => true,
        :map => {
          0 => 'FALSE',
          1 => 'TRUE',
          true => 'TRUE',
          false => 'FALSE',                                         
          'TRUE' => 'TRUE',                     
          'FALSE' => 'FALSE',                     
        }
      },
      
    }

    # @attr [Integer] type e.g. Integer
    attr_reader :type
    

    # ------------------------------------------------------------------
    # @!group Constructor & configure
    

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

    ## 
    # Set domain +type+
    #
    # @param [String] type
    def setType( typeIn )

      if  TYPE_DEFS.keys.include?( typeIn )
        @type = typeIn
      else

        msg=<<-EOS
        Invalid type '#{typeIn}'

        Valid types: #{TYPE_DEFS.keys.join(',')}
        EOS
        @logger.error "#{__method__}: #{msg}"
        raise DomainException, msg
      end
      
      
    end

    # @!endgroup

    # ------------------------------------------------------------------
    # @!group Override from base class

    ##
    # Just type, no nils counted here
    #
    # @return [Boolean] false overrides default
    def includeNil
      false
    end

    ##
    # It is safe to call +cardinality+, +domain_values+,
    # +numberOfElements+, +render_values+, ...
    #
    # @return true, extension may override
    #
    def tlaBaseType
      return TYPE_DEFS[type][:tlaBaseType] if TYPE_DEFS[type][:tlaBaseType]      
      false
    end
    
    # @return [Integer] {rangeEnd} - {rangeStart} + 1
    def cardinality
      return TYPE_DEFS[type][:cardinality] if TYPE_DEFS[type][:cardinality]
      msg =  <<-EOS
      Cardinality not applicable for #{self.class} type #{type}
      EOS
      @logger.error "#{__method__}, #{msg}"
      raise DomainException, msg
    end

    # @param i [Integer|String] domain entry to access
    # @return {rangeStart} + i 
    def domain_entry( i )
      if TYPE_DEFS[type][:map] then
        ret = TYPE_DEFS[type][:map][i]
        if ret.nil?
          msg =  <<-EOS
          Invalid value entry #{i} for #{self.class} type #{type}

          Valid values #{TYPE_DEFS[type][:map].keys.join(',')}
          EOS
          @logger.error "#{__method__}, #{msg}"
          raise DomainException, msg
        end
        ret
      else
        i
      end
    end

    # @return [ val ] no change (because integers should not be wrapped
    def stringize( val )
      val
    end

    ##
    # Domain values is the set +type+
    #
    # @return [String] type
    def render_values
      return type
    end

    ##
    # Not possible for type domain.
    def domain_range
      return TYPE_DEFS[type][:domain_range] if TYPE_DEFS[type][:domain_range]      
      msg =  <<-EOS
      domain_range not applicable for #{self.class} type #{type}
      EOS
      @logger.error "#{__method__}, #{msg}"
      raise DomainException, msg
    end
    
    # @!endgroup
    
    
  end
  
end