/*
 * ModeShape (http://www.modeshape.org)
 *
 * 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 org.infinispan.schematic.document;

import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.infinispan.schematic.document.Document.Field;
import org.infinispan.schematic.internal.document.BasicArray;
import org.infinispan.schematic.internal.document.IndexSequence;
import org.infinispan.schematic.internal.document.JsonReader;

/**
 * The constants pertaining to the JSON Schema (draft) specification.
 * 
 * @author Randall Hauch <rhauch@redhat.com> (C) 2011 Red Hat Inc.
 * @since 5.1
 */
public class JsonSchema {

    public static class Version {
        /**
         * The version-related constants for the 3rd official draft of the specification.
         * 
         * @author Randall Hauch <rhauch@redhat.com> (C) 2011 Red Hat Inc.
         * @since 5.1
         */
        public static class Draft3 {
            /**
             * The URL of the Core Meta-Schema.
             */
            public static final String CORE_METASCHEMA_URL = "http://json-schema.org/draft-03/schema#";
        }

        /**
         * The version-related constants for the most recent version.
         * 
         * @author Randall Hauch <rhauch@redhat.com> (C) 2011 Red Hat Inc.
         * @since 5.1
         */
        public static class Latest {
            /**
             * The URL of the Core Meta-Schema.
             */
            public static final String CORE_METASCHEMA_URL = Draft3.CORE_METASCHEMA_URL;
        }
    }

    /**
     * The enumeration representing the standard types used in the JSON Schema (draft) specification. Type.
     * 
     * @author Randall Hauch <rhauch@redhat.com> (C) 2011 Red Hat Inc.
     * @since 5.1
     */
    public static enum Type {
        STRING("string", new StringConverter()),
        NUMBER("number", new NumberConverter()),
        INTEGER("integer", new IntegerConverter()),
        BOOLEAN("boolean", new BooleanConverter()),
        OBJECT("object", new ObjectConverter()),
        ARRAY("array", new ArrayConverter()),
        NULL("null", new NullConverter()),
        ANY("any", new AnyConverter()),
        UNION("union", new UnionConverter()),
        UNKNOWN("unknown", new UnknownConverter());

        private static final Map<String, Type> TYPE_BY_LOWERCASE;
        private static final Map<Type, EnumSet<Type>> EQUIVALENT_TYPES;
        static {
            Map<String, Type> typeByLowercase = new HashMap<String, JsonSchema.Type>();
            typeByLowercase.put(STRING.toString().toLowerCase(), STRING);
            typeByLowercase.put(NUMBER.toString().toLowerCase(), NUMBER);
            typeByLowercase.put(INTEGER.toString().toLowerCase(), INTEGER);
            typeByLowercase.put(BOOLEAN.toString().toLowerCase(), BOOLEAN);
            typeByLowercase.put(OBJECT.toString().toLowerCase(), OBJECT);
            typeByLowercase.put(ARRAY.toString().toLowerCase(), ARRAY);
            typeByLowercase.put(NULL.toString().toLowerCase(), NULL);
            typeByLowercase.put(ANY.toString().toLowerCase(), ANY);
            typeByLowercase.put(UNION.toString().toLowerCase(), UNION);
            typeByLowercase.put(UNKNOWN.toString().toLowerCase(), UNKNOWN);
            TYPE_BY_LOWERCASE = Collections.unmodifiableMap(typeByLowercase);

            Map<Type, EnumSet<Type>> equiv = new HashMap<Type, EnumSet<Type>>();
            equiv.put(Type.STRING, EnumSet.of(Type.STRING));
            equiv.put(Type.NUMBER, EnumSet.of(Type.NUMBER, Type.INTEGER));
            equiv.put(Type.INTEGER, EnumSet.of(Type.INTEGER));
            equiv.put(Type.BOOLEAN, EnumSet.of(Type.BOOLEAN));
            equiv.put(Type.OBJECT, EnumSet.of(Type.OBJECT));
            equiv.put(Type.ARRAY, EnumSet.of(Type.ARRAY));
            equiv.put(Type.NULL, EnumSet.of(Type.NULL));
            equiv.put(Type.ANY, EnumSet.of(Type.STRING,
                                           Type.NUMBER,
                                           Type.INTEGER,
                                           Type.BOOLEAN,
                                           Type.OBJECT,
                                           Type.ARRAY,
                                           Type.NULL,
                                           Type.ANY,
                                           Type.UNION,
                                           Type.UNKNOWN));
            equiv.put(Type.UNION, EnumSet.of(Type.UNKNOWN));
            equiv.put(Type.UNKNOWN, EnumSet.of(Type.UNKNOWN));
            EQUIVALENT_TYPES = Collections.unmodifiableMap(equiv);
        }

        private final String type;
        private final ValueConverter<?> converter;

        private Type( String type,
                      ValueConverter<?> converter ) {
            this.type = type;
            this.converter = converter;
        }

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

        /**
         * Find the type enumeration literal given the (case-insensitive) name.
         * 
         * @param name the case-independent name of the type
         * @return the type, or null if there is no such type
         */
        public static Type byName( String name ) {
            return TYPE_BY_LOWERCASE.get(name.toLowerCase());
        }

        /**
         * Determine whether this type is equivalent to the supplied type.
         * 
         * @param other the type to be compared with this type
         * @return true if the types are equivalent, or false otherwise
         */
        public boolean isEquivalent( Type other ) {
            return other != null ? EQUIVALENT_TYPES.get(this).contains(other) : false;
        }

        /**
         * Attempt to convert the supplied value (with the given type) into a value compatible with this type.
         * 
         * @param actualValue the value to be converted; may be null
         * @param actualType the type of the value; may be null
         * @return the converted value, or null if the value could not be converted to this type
         */
        public Object convertValueFrom( Object actualValue,
                                        Type actualType ) {
            if (actualType == null) actualType = Type.typeFor(actualValue);
            return converter.convert(actualValue, actualType);
        }

        /**
         * Determine the type for the given value.
         * 
         * @param value the field value
         * @return the corresponding type for the value; never null
         */
        public static Type typeFor( Object value ) {
            if (value == null) return NULL;
            if (value instanceof String) // most will be strings
            return STRING;
            if (value instanceof Integer) return INTEGER;
            if (value instanceof Long) return INTEGER;
            if (value instanceof Float) return NUMBER;
            if (value instanceof Double) return NUMBER;
            if (value instanceof Boolean) return BOOLEAN;
            if (value instanceof List) // needs to be compared **before** Document
            return ARRAY;
            if (value instanceof Document) return OBJECT;
            if (value instanceof Null) return NULL;
            if (value instanceof Symbol) return STRING;
            return UNKNOWN;
        }

        /**
         * Obtain the set of types given the supplied name or iterable container of names.
         * 
         * @param typeName the String or Symbol representation of a single type name, or an Iterable&amp;?> list of names
         * @return the set of types that correspond to the supplied names; never null but possibly an empty set
         */
        public static EnumSet<Type> typesWithNames( Object typeName ) {
            if (typeName instanceof List) {
                List<Type> result = new ArrayList<Type>();
                Iterable<?> typeNames = (Iterable<?>)typeName;
                for (Object tname : typeNames) {
                    if (tname == null) continue;
                    String name = tname.toString();
                    Type type = byName(name);
                    if (type != null) result.add(type);
                }
                if (!result.isEmpty()) {
                    return EnumSet.copyOf(result);
                }
            } else if (typeName instanceof String || typeName instanceof Symbol) {
                String name = typeName.toString();
                Type type = byName(name);
                return EnumSet.of(type);
            }
            return EnumSet.noneOf(Type.class);
        }
    }

    protected static interface ValueConverter<OutputType> {
        OutputType convert( Object value,
                            Type type );
    }

    protected static class StringConverter implements ValueConverter<String> {
        @Override
        public String convert( Object value,
                               Type type ) {
            if (value == null) return null;
            switch (type) {
                case STRING:
                    return (String)value;
                case INTEGER:
                case NUMBER:
                case BOOLEAN:
                    return value.toString();
                case OBJECT: // this is a document, and we can't convert it to a string ...
                case UNION:
                case NULL:
                case ARRAY:
                    return null;
                case ANY: // fall through
                case UNKNOWN:
                    // Figure out the type ...
                    Type inferredType = Type.typeFor(value);
                    if (inferredType == Type.UNKNOWN || inferredType == type) return null;
                    return convert(value, inferredType);
            }
            return null;
        }
    }

    protected static class NumberConverter implements ValueConverter<Number> {
        @Override
        public Number convert( Object value,
                               Type type ) {
            if (value == null) return null;
            switch (type) {
                case STRING:
                    String str = value.toString();
                    return JsonReader.parseNumber(str); // may return null
                case INTEGER:
                case NUMBER:
                    return (Number)value;
                case BOOLEAN:
                    // Convert a boolean to either '1' or '0' integer ...
                    Boolean bool = (Boolean)value;
                    return Boolean.TRUE.equals(bool) ? new Integer(1) : new Integer(0);
                case OBJECT: // this is a document, and we can't convert it to a number ...
                case UNION:
                case NULL:
                case ARRAY:
                    return null;
                case ANY: // fall through
                case UNKNOWN:
                    // Figure out the type ...
                    Type inferredType = Type.typeFor(value);
                    if (inferredType == Type.UNKNOWN || inferredType == type) return null;
                    return convert(value, inferredType);
            }
            return null;
        }
    }

    protected static class IntegerConverter implements ValueConverter<Integer> {
        @Override
        public Integer convert( Object value,
                                Type type ) {
            if (value == null) return null;
            switch (type) {
                case STRING:
                    String str = value.toString();
                    Number number = JsonReader.parseNumber(str); // may return null
                    return number instanceof Integer ? (Integer)number : null;
                case INTEGER:
                    return (Integer)value;
                case NUMBER:
                    return value instanceof Integer ? (Integer)value : null;
                case BOOLEAN:
                    // Convert a boolean to either '1' or '0' integer ...
                    Boolean bool = (Boolean)value;
                    return Boolean.TRUE.equals(bool) ? new Integer(1) : new Integer(0);
                case OBJECT: // this is a document, and we can't convert it to a number ...
                case UNION:
                case NULL:
                case ARRAY:
                    return null;
                case ANY: // fall through
                case UNKNOWN:
                    // Figure out the type ...
                    Type inferredType = Type.typeFor(value);
                    if (inferredType == Type.UNKNOWN || inferredType == type) return null;
                    return convert(value, inferredType);
            }
            return null;
        }
    }

    protected static class BooleanConverter implements ValueConverter<Boolean> {
        @Override
        public Boolean convert( Object value,
                                Type type ) {
            if (value == null) return null;
            switch (type) {
                case STRING:
                    String str = value.toString();
                    if ("true".equalsIgnoreCase(str)) return Boolean.TRUE;
                    if ("false".equalsIgnoreCase(str)) return Boolean.FALSE;
                    return null;
                case INTEGER:
                    Integer i = (Integer)value;
                    if (i.intValue() == 1) return Boolean.FALSE;
                    if (i.intValue() == 0) return Boolean.FALSE;
                    return null;
                case NUMBER:
                    Number number = (Number)value;
                    if (number.intValue() == 1) return Boolean.FALSE;
                    if (number.intValue() == 0) return Boolean.FALSE;
                    return null;
                case BOOLEAN:
                    return (Boolean)value;
                case OBJECT: // this is a document, and we can't convert it to a number ...
                case UNION:
                case NULL:
                case ARRAY:
                    return null;
                case ANY: // fall through
                case UNKNOWN:
                    // Figure out the type ...
                    Type inferredType = Type.typeFor(value);
                    if (inferredType == Type.UNKNOWN || inferredType == type) return null;
                    return convert(value, inferredType);
            }
            return null;
        }
    }

    protected static class ArrayConverter implements ValueConverter<List<?>> {
        @Override
        public List<?> convert( Object value,
                                Type type ) {
            if (value == null) return null;
            switch (type) {
                case ARRAY:
                    return value instanceof List<?> ? (List<?>)value : null;
                case OBJECT: // this is a document
                    if (value instanceof List<?>) return (List<?>)value;
                    Document doc = (Document)value;
                    BasicArray array = new BasicArray(doc.size());
                    final Iterator<String> indexIter = IndexSequence.infiniteSequence();
                    for (Field field : doc.fields()) {
                        String name = field.getName();
                        String index = indexIter.next();
                        if (!index.equals(name)) {
                            // The doc's field names don't match integral index values ...
                            return null;
                        }
                        array.addValue(value);
                    }
                    return array;
                case STRING:
                case INTEGER:
                case NUMBER:
                case BOOLEAN:
                case UNION:
                case NULL:
                    return null;
                case ANY: // fall through
                case UNKNOWN:
                    // Figure out the type ...
                    Type inferredType = Type.typeFor(value);
                    if (inferredType == Type.UNKNOWN || inferredType == type) return null;
                    return convert(value, inferredType);
            }
            return null;
        }
    }

    protected static class ObjectConverter implements ValueConverter<Object> {
        @Override
        public Object convert( Object value,
                               Type type ) {
            if (value == null) return null;
            switch (type) {
                case OBJECT: // this is a document
                    return value;
                case STRING:
                case INTEGER:
                case NUMBER:
                case BOOLEAN:
                case UNION:
                case NULL:
                    return null;
                case ARRAY:
                    // The array can already be treated as a document ...
                    return value instanceof Document ? value : null;
                case ANY: // fall through
                case UNKNOWN:
                    // Figure out the type ...
                    Type inferredType = Type.typeFor(value);
                    if (inferredType == Type.UNKNOWN || inferredType == type) return null;
                    return convert(value, inferredType);
            }
            return null;
        }
    }

    protected static class NullConverter implements ValueConverter<Object> {
        @Override
        public Object convert( Object value,
                               Type type ) {
            if (value == null || value instanceof Null) return Null.getInstance();
            return null;
        }
    }

    protected static class UnionConverter implements ValueConverter<Object> {
        @Override
        public Object convert( Object value,
                               Type type ) {
            return null;
        }
    }

    protected static class UnknownConverter implements ValueConverter<Object> {
        @Override
        public Object convert( Object value,
                               Type type ) {
            return value;
        }
    }

    protected static class AnyConverter implements ValueConverter<Object> {
        @Override
        public Object convert( Object value,
                               Type type ) {
            return value;
        }
    }

}
