package com.hfg.util;


import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import com.hfg.util.collection.CollectionUtil;

//------------------------------------------------------------------------------
/**
 Enumeration of basic data types.

 @author J. Alex Taylor, hairyfatguy.com
 */
//------------------------------------------------------------------------------
// com.hfg XML/HTML Coding Library
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// J. Alex Taylor, President, Founder, CEO, COO, CFO, OOPS hairyfatguy.com
// jataylor@hairyfatguy.com
//------------------------------------------------------------------------------

public enum DataType
{
   BIGINT,
   BOOLEAN,
   CHARACTER,
   DATE,
   DOUBLE,
   FLOAT,
   INTEGER,
   NUMBER,
   STRING;

   private static Map<String, DataType> sLookupMap;
   static
   {
      BIGINT.addAltName("long");
      BOOLEAN.addAltName("bool");
      CHARACTER.addAltName("char");
      DATE.addAltName("datetime");
      DOUBLE.addAltName("real");
      INTEGER.addAltName("int");
      NUMBER.addAltName("num");
      STRING.addAltName("varchar");
   }

   private Set<String> mAltNames;


   //---------------------------------------------------------------------------
   /**
    * Since an Enum's valueOf() can't be overridden, this is our more flexible lookup.
    * @param inClass the Class value for which the corresponding DataType will be returned
    * @return the DataType corresponding to the specified Class value
    */
   public static DataType fromClass(Class inClass)
   {
      DataType value = null;

      if (inClass != null)
      {
         if (String.class.isAssignableFrom(inClass))
         {
            value = DataType.STRING;
         }
         else if (Double.class.isAssignableFrom(inClass))
         {
            value = DataType.DOUBLE;
         }
         else if (Float.class.isAssignableFrom(inClass))
         {
            value = DataType.FLOAT;
         }
         else if (Integer.class.isAssignableFrom(inClass))
         {
            value = DataType.INTEGER;
         }
         else if (Long.class.isAssignableFrom(inClass))
         {
            value = DataType.BIGINT;
         }
         else if (Boolean.class.isAssignableFrom(inClass))
         {
            value = DataType.BOOLEAN;
         }
         else if (Date.class.isAssignableFrom(inClass))
         {
            value = DataType.DATE;
         }
         else if (Character.class.isAssignableFrom(inClass))
         {
            value = DataType.CHARACTER;
         }
      }

      return value;
   }

   //---------------------------------------------------------------------------
   /**
    * Since an Enum's valueOf() can't be overridden, this is our more flexible lookup.
    * @param inStringValue the String value for which the corresponding DataType will be returned
    * @return the DataType corresponding to the specified String value
    */
   public static DataType fromString(String inStringValue)
   {
      if (null == sLookupMap)
      {
         initLookupMap();
      }

      return sLookupMap.get(inStringValue != null ? inStringValue.toLowerCase() : null);
   }

   //---------------------------------------------------------------------------
   private static synchronized void initLookupMap()
   {
      sLookupMap = new HashMap<>(20);
      for (DataType value : values())
      {
         sLookupMap.put(value.name().toLowerCase(), value);
         if (CollectionUtil.hasValues(value.mAltNames))
         {
            for (String altName : value.mAltNames)
            {
               sLookupMap.put(altName.toLowerCase(), value);
            }
         }
      }
   }

   //---------------------------------------------------------------------------
   private DataType addAltName(String inValue)
   {
      if (null == mAltNames)
      {
         mAltNames = new HashSet<>(2);
      }

      mAltNames.add(inValue.toLowerCase());

      return this;
   }

   //---------------------------------------------------------------------------
   public boolean isNumeric()
   {
      return (this == BIGINT || this == DOUBLE || this == FLOAT || this == INTEGER || this == NUMBER);   
   }
   
   //---------------------------------------------------------------------------
   public static DataType guessDataTypeFromValues(Collection<? extends Object> inDataValues)
   {
      DataType returnDataType = DataType.STRING;


      if (CollectionUtil.hasValues(inDataValues))
      {
         // Extract the unique set of Classes represented by the specified data values
         Set<Class> dataTypeClasses = new HashSet<>(4);
         for (Object value : inDataValues)
         {
            if (value != null)
            {
               dataTypeClasses.add(value.getClass());
            }
         }

         // Convert the Set of Classes to a Set of DataTypes
         Set<DataType> dataTypes = new HashSet<>(4);
         for (Class clazz : dataTypeClasses)
         {
            DataType dataType = DataType.fromClass(clazz);
            if (dataType != null)
            {
               dataTypes.add(dataType);
            }
         }

         if (1 == dataTypes.size())
         {
            returnDataType = dataTypes.iterator().next();
         }
         else
         {
            // There are a mixture of DataTypes.
            // Just return STRING unless all the types are numeric.
            boolean allNumeric = true;
            for (DataType dataType : dataTypes)
            {
               if (! dataType.isNumeric())
               {
                  allNumeric = false;
                  break;
               }
            }

            if (allNumeric)
            {
               // All DataTypes present are numeric - return the broadest type.
               // For example if the DataTypes present are DOUBLE and INTEGER, return DOUBLE.
               if (dataTypes.contains(DataType.DOUBLE))
               {
                  returnDataType = DataType.DOUBLE;
               }
               else if (dataTypes.contains(DataType.FLOAT))
               {
                  returnDataType = DataType.FLOAT;
               }
               else if (dataTypes.contains(DataType.BIGINT))
               {
                  returnDataType = DataType.BIGINT;
               }
            }
         }
      }

      return returnDataType;
   }
}