/*
Copyright (c) 2011 James Ahlborn

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package com.healthmarketscience.jackcess.impl;

import java.io.IOException;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

import com.healthmarketscience.jackcess.DataType;
import com.healthmarketscience.jackcess.PropertyMap;

/**
 * Map of properties for a database object.
 *
 * @author James Ahlborn
 */
public class PropertyMapImpl implements PropertyMap
{
  private static final Map<String,PropDef> DEFAULT_TYPES =
    new HashMap<String,PropDef>();

  static {
    DEFAULT_TYPES.put(ACCESS_VERSION_PROP, new PropDef(DataType.TEXT, false));
    DEFAULT_TYPES.put(TITLE_PROP, new PropDef(DataType.TEXT, false));
    DEFAULT_TYPES.put(AUTHOR_PROP, new PropDef(DataType.TEXT, false));
    DEFAULT_TYPES.put(COMPANY_PROP, new PropDef(DataType.TEXT, false));

    DEFAULT_TYPES.put(DEFAULT_VALUE_PROP, new PropDef(DataType.MEMO, true));
    DEFAULT_TYPES.put(REQUIRED_PROP, new PropDef(DataType.BOOLEAN, true));
    DEFAULT_TYPES.put(ALLOW_ZERO_LEN_PROP, new PropDef(DataType.BOOLEAN, true));
    DEFAULT_TYPES.put(DECIMAL_PLACES_PROP, new PropDef(DataType.BYTE, true));
    DEFAULT_TYPES.put(FORMAT_PROP, new PropDef(DataType.TEXT, true));
    DEFAULT_TYPES.put(INPUT_MASK_PROP, new PropDef(DataType.TEXT, true));
    DEFAULT_TYPES.put(CAPTION_PROP, new PropDef(DataType.MEMO, false));
    DEFAULT_TYPES.put(VALIDATION_RULE_PROP, new PropDef(DataType.TEXT, true));
    DEFAULT_TYPES.put(VALIDATION_TEXT_PROP, new PropDef(DataType.TEXT, true));
    DEFAULT_TYPES.put(GUID_PROP, new PropDef(DataType.BINARY, true));
    DEFAULT_TYPES.put(DESCRIPTION_PROP, new PropDef(DataType.MEMO, false));
    DEFAULT_TYPES.put(RESULT_TYPE_PROP, new PropDef(DataType.BYTE, true));
    DEFAULT_TYPES.put(EXPRESSION_PROP, new PropDef(DataType.MEMO, true));
    DEFAULT_TYPES.put(DISPLAY_CONTROL_PROP, new PropDef(DataType.INT, false));
    DEFAULT_TYPES.put(TEXT_FORMAT_PROP, new PropDef(DataType.BYTE, false));
    DEFAULT_TYPES.put(IME_MODE_PROP, new PropDef(DataType.BYTE, false));
    DEFAULT_TYPES.put(IME_SENTENCE_MODE_PROP, new PropDef(DataType.BYTE, false));
  }

  private final String _mapName;
  private final short _mapType;
  private final Map<String,Property> _props =
    new LinkedHashMap<String,Property>();
  private final PropertyMaps _owner;

  public PropertyMapImpl(String name, short type, PropertyMaps owner) {
    _mapName = name;
    _mapType = type;
    _owner = owner;
  }

  @Override
  public String getName() {
    return _mapName;
  }

  public short getType() {
    return _mapType;
  }

  public PropertyMaps getOwner() {
    return _owner;
  }

  @Override
  public int getSize() {
    return _props.size();
  }

  @Override
  public boolean isEmpty() {
    return _props.isEmpty();
  }

  @Override
  public Property get(String name) {
    return _props.get(DatabaseImpl.toLookupName(name));
  }

  @Override
  public Object getValue(String name) {
    return getValue(name, null);
  }

  @Override
  public Object getValue(String name, Object defaultValue) {
    Property prop = get(name);
    Object value = defaultValue;
    if((prop != null) && (prop.getValue() != null)) {
      value = prop.getValue();
    }
    return value;
  }

  @Override
  public PropertyImpl put(String name, Object value) {
    return put(name, null, value, false);
  }

  @Override
  public PropertyImpl put(String name, DataType type, Object value) {
    return put(name, type, value, false);
  }

  @Override
  public void putAll(Iterable<? extends Property> props) {
    if(props == null) {
      return;
    }

    for(Property prop : props) {
      put(prop);
    }
  }

  public PropertyImpl put(Property prop) {
    return put(prop.getName(), prop.getType(), prop.getValue(), prop.isDdl());
  }

  /**
   * Puts a property into this map with the given information.
   */
  @Override
  public PropertyImpl put(String name, DataType type, Object value,
                          boolean isDdl) {
    PropertyImpl prop = (PropertyImpl)createProperty(name, type, value, isDdl);
    _props.put(DatabaseImpl.toLookupName(name), prop);
    return prop;
  }

  @Override
  public PropertyImpl remove(String name) {
    return (PropertyImpl)_props.remove(DatabaseImpl.toLookupName(name));
  }

  @Override
  public Iterator<Property> iterator() {
    return _props.values().iterator();
  }

  @Override
  public void save() throws IOException {
    getOwner().save();
  }

  @Override
  public String toString() {
    return toString(this);
  }

  public static String toString(PropertyMap map) {
    StringBuilder sb = new StringBuilder();
    sb.append(PropertyMaps.DEFAULT_NAME.equals(map.getName()) ?
              "<DEFAULT>" : map.getName())
      .append(" {");
    for(Iterator<Property> iter = map.iterator(); iter.hasNext(); ) {
      sb.append(iter.next());
      if(iter.hasNext()) {
        sb.append(",");
      }
    }
    sb.append("}");
    return sb.toString();
  }

  public static Property createProperty(String name, DataType type, Object value) {
    return createProperty(name, type, value, false);
  }

  public static Property createProperty(String name, DataType type,
                                        Object value, boolean isDdl) {
    // see if this is a builtin property that we already understand
    PropDef pd = DEFAULT_TYPES.get(name);

    if(value instanceof PropertyMap.EnumValue) {
      // convert custom enum to stored value
      value = ((PropertyMap.EnumValue)value).getValue();
    }

    if(pd != null) {
      // update according to the default info
      type = ((type == null) ? pd._type : type);
      isDdl |= pd._isDdl;
    } else if(type == null) {
      // choose the type based on the value
      if(value instanceof String) {
        type = DataType.TEXT;
      } else if(value instanceof Boolean) {
        type = DataType.BOOLEAN;
      } else if(value instanceof Byte) {
        type = DataType.BYTE;
      } else if(value instanceof Short) {
        type = DataType.INT;
      } else if(value instanceof Integer) {
        type = DataType.LONG;
      } else if(value instanceof Float) {
        type = DataType.FLOAT;
      } else if(value instanceof Double) {
        type = DataType.DOUBLE;
      } else if((value instanceof Date) || (value instanceof LocalDateTime)) {
        type = DataType.SHORT_DATE_TIME;
      } else if(value instanceof byte[]) {
        type = DataType.OLE;
      } else if(value instanceof Long) {
        type = DataType.BIG_INT;
      } else {
        throw new IllegalArgumentException(
            "Could not determine type for property " + name +
            " with value " + value);
      }
    }

    return new PropertyImpl(name, type, value, isDdl);
  }

  /**
   * Info about a property defined in a PropertyMap.
   */
  static final class PropertyImpl implements PropertyMap.Property
  {
    private final String _name;
    private final DataType _type;
    private final boolean _ddl;
    private Object _value;

    private PropertyImpl(String name, DataType type, Object value,
                         boolean ddl) {
      _name = name;
      _type = type;
      _ddl = ddl;
      _value = value;
    }

    @Override
    public String getName() {
      return _name;
    }

    @Override
    public DataType getType() {
      return _type;
    }

    @Override
    public Object getValue() {
      return _value;
    }

    @Override
    public void setValue(Object newValue) {
      _value = newValue;
    }

    @Override
    public boolean isDdl() {
      return _ddl;
    }

    @Override
    public String toString() {
      Object val = getValue();
      if(val instanceof byte[]) {
        val = ByteUtil.toHexString((byte[])val);
      }
      return getName() + "[" + getType() + (_ddl ? ":ddl" : "") + "]=" + val;
    }
  }

  /**
   * Helper for holding info about default properties
   */
  private static final class PropDef
  {
    private final DataType _type;
    private final boolean _isDdl;

    private PropDef(DataType type, boolean isDdl) {
      _type = type;
      _isDdl = isDdl;
    }
  }
}