//
// SwitchRMI  Framework
// Copyright (c) 2000-2002 by Michael J. Henderson & Associates.
//
// Michael Henderson
// http://switchrmi.sf.net
// mailto:mikehenderson@dunelm.org.uk
//
// This library is free software.
//
// You may redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License as published by the Free Software Foundation.
//
// Version 2.1 of the license should be included with this distribution in
// the file LICENSE, as well as License.html. If the license is not
// included with this distribution, you may find a copy at the FSF web
// site at 'www.gnu.org' or 'www.fsf.org', or you may write to the
// Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139 USA.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied waranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// $Id: BeanMap.java,v 1.1 2002/11/11 22:19:48 mikehenderson Exp $
package com.mjh.util;

import java.beans.*;

import java.lang.reflect.*;

import java.util.*;

import org.apache.log4j.Logger;

/**
 * BeanMap provides an adaptor for Java Beans to allow them to be treated as a java.util.Map.
 * <p>
 * BeanMap is pretty good at coercing string values into the appropriate primitive type
 * for a bean setter method argument.
 * <p>
 * For example:
 * <p>
 * <code>
 *    MyBean myBean = new MyBean();<br>
 *    BeanMap myMap = new BeamMap(myBean);<br>
 *    myMap.put("totalCount", "100");<br>
 *    Number value = (Number)myMap.get("totalCount");<br>
 * </code>
 * <p>
 * The above code will call the <code>setTotalCount()</code> method on myBean with the string value of "100"
 * coerced to the required integer argument. Then call the <code>getTotalCount()</code> method on myBean and convert
 * the int return value to the Java primitive wrapper class.
 * <p>
 * The coercion makes BeanMap particularly useful to initialize beans from values stored in text files.
 *
 * @author Mike Henderson
 */
public class BeanMap implements java.util.Map
{
    private static final Logger log = Logger.getLogger(BeanMap.class.getName());
    private Object bean;
    private BeanInfo info;
    private Map pdMap = new HashMap();

    public BeanMap(Object object)
            throws IntrospectionException
    {
        bean = object;
        info = Introspector.getBeanInfo(object.getClass());

        PropertyDescriptor[] pd = info.getPropertyDescriptors();

        for (int i = 0; i < pd.length; i++)
        {
            pdMap.put(pd[i].getName(), pd[i]);
        }
    }

    private PropertyDescriptor getPropertyDescriptor(String key)
    {
        return (PropertyDescriptor) pdMap.get(key);
    }

    public Object put(Object key, Object value)
    {
        Object prev = null;
        PropertyDescriptor pd = (PropertyDescriptor) pdMap.get(key);

        log.debug("put() pd = " + pd);
        log.debug("put() key = " + key);
        log.debug("put() value = " + value);

        if (pd != null)
        {
            Class clazz = pd.getPropertyType();

            if (!clazz.getName().equals(value.getClass().getName()))
            {
                value = coerceValue(value, clazz);
            }

            Method writer = pd.getWriteMethod();

            log.debug("put() writer = " + writer);
            prev = get(key);

            if (writer != null)
            {
                try
                {
                    writer.invoke(bean, new Object[] { value });
                }
                catch (Exception ex)
                {
                    ex.printStackTrace();
                }
            }
        }

        return prev;
    }

    public Object get(Object key)
    {
        Object result = null;
        PropertyDescriptor pd = (PropertyDescriptor) pdMap.get(key);

        if (pd != null)
        {
            Method reader = pd.getReadMethod();

            if (reader != null)
            {
                try
                {
                    result = reader.invoke(bean, new Object[] {  });
                }
                catch (Exception ex)
                {
                }
            }
        }

        return result;
    }

    public boolean containsKey(Object key)
    {
        return (pdMap.get(key) != null);
    }

    public boolean containsValue(Object o)
    {
        return false;
    }

    public void clear()
    {
    }

    public Object remove(Object key)
    {
        return null;
    }

    public Collection values()
    {
        return getAll().values();
    }

    public Set keySet()
    {
        return pdMap.keySet();
    }

    public Set entrySet()
    {
        HashSet set = new HashSet();
        PropertyDescriptor[] pd = info.getPropertyDescriptors();

        for (int i = 0; i < pd.length; i++)
        {
            set.add(new BeanMapEntry(pd[i].getName()));
        }

        return set;
    }

    public boolean equals(Object o)
    {
        return (o instanceof BeanMap && ((BeanMap) o).bean.equals(this.bean));
    }

    public int size()
    {
        return info.getPropertyDescriptors().length;
    }

    public Map getAll()
    {
        return new HashMap(this);
    }

    public void putAll(Map map)
    {
        Iterator keys = map.keySet().iterator();

        while (keys.hasNext())
        {
            Object key = keys.next();

            log.debug("putAll() key = " + key);
            put(key, map.get(key));
        }
    }

    public boolean isEmpty()
    {
        return false;
    }

    private Object coerceValue(Object value, Class targetClazz)
    {
        if (value instanceof String)
        {
            String string = (String) value;
            String targetClassName = targetClazz.getName();

            if (targetClassName.equals("int")
                || targetClassName.equals("java.lang.Integer"))
            {
                value = new Integer(string);
            }
            else if (targetClassName.equals("long")
                     || targetClassName.equals("java.lang.Long"))
            {
                value = new Long(string);
            }
            else if (targetClassName.equals("float")
                     || targetClassName.equals("java.lang.Float"))
            {
                value = new Float(string);
            }
            else if (targetClassName.equals("double")
                     || targetClassName.equals("java.lang.Double"))
            {
                value = new Double(string);
            }
            else if (targetClassName.equals("short")
                     || targetClassName.equals("java.lang.Short"))
            {
                value = new Short(string);
            }
            else if (targetClassName.equals("char")
                     || targetClassName.equals("java.lang.Character"))
            {
                value = new Character(string.charAt(0));
            }
            else if (targetClassName.equals("byte")
                     || targetClassName.equals("java.lang.byte"))
            {
                value = new Byte(string);
            }
        }

        return value;
    }

    public class BeanMapEntry
        implements Map.Entry
    {
        Object key;

        public BeanMapEntry(Object key)
        {
            this.key = key;
        }

        public boolean equals(Object o)
        {
            return (o instanceof Map.Entry
                   && key.equals(((Map.Entry) o).getKey())
                   && getValue().equals(((Map.Entry) o).getValue()));
        }

        public int hashCode()
        {
            return key.hashCode() ^ getValue().hashCode();
        }

        public Object getKey()
        {
            return key;
        }

        public Object getValue()
        {
            return get(key);
        }

        public Object setValue(Object value)
        {
            return put(key, value);
        }
    }
}