/*
************************************************************************
* Copyright (c) 2007-2008, International Business Machines
* Corporation and others.  All Rights Reserved.
************************************************************************
*/
#ifndef FLDSET_H_
#define FLDSET_H_

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING
#include "unicode/calendar.h"
#include "unicode/ucal.h"
#include "unicode/udat.h"
#include "unicode/udbgutil.h"
#include "unicode/dbgutil.h"
#include "unicode/unistr.h"

#define U_FIELDS_SET_MAX  64

/**
 * This class represents a collection of integer values (fields), each designated by
 * one of a particular set of enum values.  Each integer value (int32_t) is optional and
 * may or may not be set. 
 * 
 * @internal ICU 3.8
 */
class FieldsSet {
    protected:
        /**
         * subclass interface - construct the FieldsSet to reference one of the standard
         * enumerations.
         * @param whichEnum which enumaration value goes with this set. Will be used to calculate string
         * values and also enum size.
         * @see UDebugEnumType
         */
        FieldsSet(UDebugEnumType whichEnum);
        
        /**
         * subclass interface - construct the FieldsSet without using a standard enum type.
         * @param fieldCount how many fields this object can hold.
         */
        FieldsSet(int32_t fieldsCount);

    public:
    
      /**
       * Compare two sets. In typical test usage, 'this' is the resul of 
       * a tested operation, and 'other' is the predefined expected value.
       * 
       * @param other the set to compare against.
       * @param status will return U_ILLEGAL_ARGUMENT_ERROR if sets are not the same size
       * @return a formatted string listing which fields are set in 
       *   this, with the comparison made agaainst those fields in other.
       */
      UnicodeString diffFrom(const FieldsSet& other, UErrorCode &status) const;
      
    public:
      /**
       * Fill-in fields from a specified string, such as "NAME1=VALUE1,NAME2=VALUE2", etc. 
       * @param str string to parse
       * @param status status of parse
       * @return the number of valid parsed fields on success, or a negative number on failure.
       */
      int32_t parseFrom(const UnicodeString& str, UErrorCode& status) { return parseFrom(str,NULL,status); }
      
      /**
       * Fill-in fields from a specified string, such as "NAME1=VALUE1,NAME2=VALUE2", etc. 
       * @param inheritFrom if a field's value is given as 0-length, such as NAME1 in "NAME1=,NAME2=VALUE2", 
       * the specified FieldsSet's value for NAME1 will be copied into this.
       * @param str string to parse
       * @param status status of parse
       * @return the number of valid parsed fields on success, or a negative number on failure.
       */
      int32_t parseFrom(const UnicodeString& str, const FieldsSet& inheritFrom, UErrorCode& status) { return parseFrom(str, &inheritFrom, status); }
      
      /**
       * Fill-in fields from a specified string, such as "NAME1=VALUE1,NAME2=VALUE2", etc. 
       * @param inheritFrom if a field's value is given as 0-length, such as NAME1 in "NAME1=,NAME2=VALUE2", 
       * the specified FieldsSet's value for NAME1 will be copied into this.
       * @param str string to parse
       * @param status status of parse
       * @return the number of valid parsed fields on success, or a negative number on failure.
       */
      int32_t parseFrom(const UnicodeString& str, const 
              FieldsSet* inheritFrom, UErrorCode& status);
      
    protected:
      /**
       * Callback interface for subclass.
       * This function is called when parsing a field name, such as "MONTH"  in "MONTH=4".
       * Base implementation is to lookup the enum value using udbg_* utilities, or else as an integer if
       * enum is not available.
       * 
       * If there is a special directive, the implementer can catch it here and return -1 after special processing completes.
       * 
       * @param inheritFrom the set inheriting from - may be null.
       * @param name the field name (key side)
       * @param substr the string in question (value side)
       * @param status error status - set to error for failure.
       * @return field number, or negative if field should be skipped.
       */
      virtual int32_t handleParseName(const FieldsSet* inheritFrom, const UnicodeString& name, const UnicodeString& substr, UErrorCode& status);

      /**
       * Callback interface for subclass.
       * Base implementation is to call parseValueDefault(...)
       * @param inheritFrom the set inheriting from - may be null.
       * @param field which field is being parsed
       * @param substr the string in question (value side)
       * @param status error status - set to error for failure.
       * @see parseValueDefault
       */
      virtual void handleParseValue(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status);
                
      /**
       * the default implementation for handleParseValue.
       * Base implementation is to parse a decimal integer value, or inherit from inheritFrom if the string is 0-length.
       * Implementations of this function should call set(field,...) on successful parse.
       * @see handleParseValue
       */
      void parseValueDefault(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status);      


      /**
       * convenience implementation for handleParseValue
       * attempt to load a value from an enum value using udbg_enumByString()
       * if fails, will call parseValueDefault()
       * @see handleParseValue
       */
      void parseValueEnum(UDebugEnumType type, const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status);

    private:
      /** 
       * Not callable - construct a default FieldsSet
       * @internal
       */
      FieldsSet();
      
      /**
       * construct the object.
       * @internal
       */
      void construct(UDebugEnumType whichEnum, int32_t fieldCount);

    public:
    /**
     * destructor
     */
     virtual ~FieldsSet();

    /**
     * Mark all fields as unset
     */
    void clear();
    
    /**
     * Mark a specific field as unset
     * @param field the field to unset
     */
    void clear(int32_t field);
    
    /**
     * Set a specific field
     * @param field the field to set (i.e. enum value)
     * @param value the field's value
     */
    void set(int32_t field, int32_t value);
    
    UBool isSet(int32_t field) const;

    /**
     * Return the field's value
     * @param field which field
     * @return field's value, or -1 if unset.
     */
    int32_t get(int32_t field) const;
    
    /**
     * Return true if both FieldsSet objects either are based on the same enum, or have the same number of fields.
     */
    UBool isSameType(const FieldsSet& other) const;

    /**
     * @return the number of fields 
     */
    int32_t fieldCount() const;
    
    protected:
       int32_t fValue[U_FIELDS_SET_MAX];
       UBool fIsSet[U_FIELDS_SET_MAX];
    protected:
       int32_t fFieldCount;
       UDebugEnumType fEnum;
};

/**
 * A subclass of FieldsSet representing the fields in a Calendar
 * @see Calendar
 */
class CalendarFieldsSet : public FieldsSet {
public:
    CalendarFieldsSet();
    virtual ~CalendarFieldsSet();

//        void clear(UCalendarDateFields field) { clear((int32_t)field); }
//        void set(UCalendarDateFields field, int32_t amount) { set ((int32_t)field, amount); }

//        UBool isSet(UCalendarDateFields field) const { return isSet((int32_t)field); }
//        int32_t get(UCalendarDateFields field) const { return get((int32_t)field); }

    /**
     * @param matches fillin to hold any fields different. Will have the calendar's value set on them.
     * @return true if the calendar matches in these fields.
     */
    UBool matches(Calendar *cal, CalendarFieldsSet &diffSet,
            UErrorCode& status) const;

    /**
     * For each set field, set the same field on this Calendar.
     * Doesn't clear the Calendar first.
     * @param cal Calendar to modify
     * @param status Contains any errors propagated by the Calendar.
     */
    void setOnCalendar(Calendar *cal, UErrorCode& status) const;
        
protected:
    /**
     * subclass override 
     */
    void handleParseValue(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status);
};

/**
 * This class simply implements a set of date and time styles
 * such as DATE=SHORT  or TIME=SHORT,DATE=LONG, such as would be passed
 * to DateFormat::createInstance()
 * @see DateFormat
 */
class DateTimeStyleSet : public FieldsSet {
    public:
        DateTimeStyleSet();
        virtual ~DateTimeStyleSet();

        /** 
         * @return the date style, or UDAT_NONE if not set
         */
        UDateFormatStyle getDateStyle() const;
        
        /** 
         * @return the time style, or UDAT_NONE if not set
         */
        UDateFormatStyle getTimeStyle() const;
    protected:
        void handleParseValue(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status);
        int32_t handleParseName(const FieldsSet* inheritFrom, const UnicodeString& name, const UnicodeString& substr, UErrorCode& status);
};


#endif /*!UCONFIG_NO_FORMAT*/
#endif /*FLDSET_H_*/