package org.neo4j.rdf.model;

import java.text.ParseException;

import org.neo4j.meta.model.RdfUtil;

/**
 * A literal value, i.e. String, int, byte, etc.
 *
 * Cases:
 *  o value instance of Primitive (not String)
 *      -> just keep it
 *  o value is String and a datatype is supplied
 *      -> convert it if the datatype if supported, otherwise throw
 *  o value is String and no datatype is supplied
 *      -> check in meta model (if there is a meta) and convert it later (add,get)
 *
 */
public class Literal implements Value
{
    private final Object value;
    private final Uri datatype;
    private final String language;

    // TODO: We need to detect what data type people throw in here and if
    // it's something we support natively (i.e. Java's primitive types) then
    // we make sure we convert it properly... or else people will just embed
    // their longs (for example) as strings, with datatype xsd:long. Ugly,
    // but that's how for example SAIL works. :(

    public Literal( Object value )
    {
        this( value, null, null );
    }

    public Literal( Object value, Uri datatype )
    {
        this( value, datatype, null );
    }

    public Literal( Object value, Uri datatype, String language )
    {
        this.datatype = datatype;
        this.language = language;

        Object temporaryValue = value;
        if ( !( value instanceof String ) )
        {
            // Assume primitive!
            // Just keep it as is
        }
        else if ( value instanceof String )
        {
            // TODO: outcommented for now, in the interest of getting the
            // SAIL tests to pass
//            if ( datatype != null )
//            {
//                // Convert according to datatype
//                temporaryValue = tryConvertValue( ( String ) value, datatype );
//            }
//            else
//            {
//                // Let it be for the store/meta to convert later
//            }
        }

        this.value = temporaryValue;
    }

    private static Object tryConvertValue( String value, Uri datatype )
    {
        try
        {
            return RdfUtil.getRealValue( datatype.getUriAsString(), value );
        }
        catch ( ParseException e )
        {
            throw new RuntimeException( e );
        }
    }

    /**
     * The literal value of this literal
     * @return the value
     */
    public Object getValue()
    {
        return this.value;
    }

    /**
     * The optional data type of this literal
     * @return the optional data type of this literal
     */
    public Uri getDatatype()
    {
        return this.datatype;
    }

    /**
     * The optional language tag for this literal
     * @return the optional language tag for this literal
     */
    public String getLanguage()
    {
        return this.language;
    }

    /**
     * Returns <code>false</code> (a literal is not a wildcard).
     * @return <code>false</code>
     */
    public boolean isWildcard()
    {
        return false;
    }
    
    @Override
    public int hashCode()
    {
        return getValue().hashCode(); 
    }

    @Override
    public boolean equals( Object o )
    {
        if ( o instanceof Literal )
        {
            return getValue().equals( ( ( Literal ) o ).getValue() );
        }
        return false;
    }
    
   @Override
    public String toString()
    {
        return "Literal[" + this.value + "]";
    }
}