/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements.  See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership.  The ASF licenses this file
* to you 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.apache.openoffice.ooxml.schema.simple;

import java.util.Map;
import java.util.Vector;

import org.apache.openoffice.ooxml.schema.misc.Log;
import org.apache.openoffice.ooxml.schema.model.simple.BuiltInType;
import org.apache.openoffice.ooxml.schema.model.simple.Restriction;

public class NumberNode<T extends Comparable<T>>
    implements ISimpleTypeNode
{
    NumberNode (final BuiltInType eType)
    {
        meType = eType;
        mbIsList = false;
    }
    
    
    
    
    public BuiltInType GetNumberType ()
    {
        return meType;
    }
    
    
    
    
    T ParseString (final String sValue)
    {
        switch(meType)
        {
            case Float:
                return (T)(Float)Float.parseFloat(sValue);
                
            case Double:
                return (T)(Double)Double.parseDouble(sValue);
                
            case Byte:
                return (T)(Byte)Byte.parseByte(sValue);

            case Int:
            case UnsignedShort:
                return (T)(Integer)Integer.parseInt(sValue);

            case Short:
            case UnsignedByte:
                return (T)(Short)Short.parseShort(sValue);

            case Long:
            case UnsignedInt:
            case Integer:
                return (T)(Long)Long.parseLong(sValue);
                
            default:
                throw new RuntimeException("unsupported type "+meType);
        }
    }
    
    
    
    
    @Override
    public void ApplyRestriction (
        final Restriction aNode,
        final Map<String,Integer> aValueToIdMap)
    {
        if (aNode.HasFeature(Restriction.MinExclusiveBit))
            ApplyMinimum(ParseString(aNode.GetMinExclusive()), false);
        if (aNode.HasFeature(Restriction.MinInclusiveBit))
            ApplyMinimum(ParseString(aNode.GetMinInclusive()), true);

        if (aNode.HasFeature(Restriction.MaxExclusiveBit))
            ApplyMaximum(ParseString(aNode.GetMaxExclusive()), false);
        if (aNode.HasFeature(Restriction.MaxInclusiveBit))
            ApplyMaximum(ParseString(aNode.GetMaxInclusive()), true);
        
        if (aNode.HasFeature(Restriction.EnumerationBit))
        {
            final Vector<T> aValues = new Vector<>();
            for (final String sEnumerationValue : aNode.GetEnumeration())
                aValues.add(ParseString(sEnumerationValue));
            ApplyEnumeration(aValues);
        }
    }

    
    

    @Override
    public void Print (final Log aLog)
    {
        aLog.printf("%s\n", toString());
    }

    
    
    
    @Override
    public String toString ()
    {
        final StringBuffer sMessage = new StringBuffer();
        sMessage.append(meType);
        if (maEnumeration != null)
        {
            sMessage.append(", restricted to values");
            for (final T nValue : maEnumeration)
            {
                sMessage.append(' ');
                sMessage.append(nValue);
            }
        }
        else if (maMinimumValue!=null || maMaximumValue!=null)
        {
            sMessage.append(" restricted to ");
          
            if (maMinimumValue != null)
            {
                sMessage.append(maMinimumValue);
                if (mbIsMinimumInclusive)
                    sMessage.append(" <= ");
                else
                    sMessage.append(" < ");
            }
            sMessage.append("value");
            if (maMaximumValue != null)
            {
                if (mbIsMaximumInclusive)
                    sMessage.append(" <= ");
                else
                    sMessage.append(" < ");
                sMessage.append(maMaximumValue);
            }
        }
        else
            sMessage.append(", not restricted");

        return sMessage.toString();
    }


    
    
    private void ApplyMinimum (
        final T nValue,
        final boolean bIsInclusive)
    {
        if (maEnumeration != null)
            throw new RuntimeException("minimum can not be applied to an enumeration");
        else if (maMinimumValue != null)
        {
            final int nComparison = maMinimumValue.compareTo(nValue);
            if (nComparison > 0)
                throw new RuntimeException("second restriction tries to enlarge value space");
            else if (nComparison == 0)
                if (mbIsMinimumInclusive && ! bIsInclusive)
                    throw new RuntimeException("second restriction tries to enlarge value space");
        }
        maMinimumValue = nValue;
        mbIsMinimumInclusive = bIsInclusive;
    }
    
    
    
    

    private void ApplyMaximum (
        final T nValue,
        final boolean bIsInclusive)
    {
        if (maEnumeration != null)
            throw new RuntimeException("maximum can not be applied to an enumeration");
        else if (maMaximumValue != null)
        {
            final int nComparison = maMaximumValue.compareTo(nValue);
            if (nComparison < 0)
                throw new RuntimeException("second restriction tries to enlarge value space");
            else if (nComparison == 0) 
                if ( ! mbIsMaximumInclusive && bIsInclusive)
                    throw new RuntimeException("second restriction tries to enlarge value space");
        }
        maMaximumValue = nValue;
        mbIsMaximumInclusive = bIsInclusive;
    }
    

    
    
    private void ApplyEnumeration (final Vector<T> aValues)
    {
        if (maEnumeration!=null || maMaximumValue!=null || maMinimumValue!=null)
            throw new RuntimeException("can not apply enumeration to existing restriction");
        maEnumeration = aValues;
    }
    
    
    

    @Override
    public boolean IsList ()
    {
        return mbIsList;
    }
    
    
    
    
    @Override
    public void SetIsList ()
    {
        mbIsList = true;
    }
    
    
    
    
    @Override
    public void AcceptVisitor (final ISimpleTypeNodeVisitor aVisitor)
    {
        aVisitor.Visit(this);
    }
    
    
    public enum RestrictionType
    {
        Size,
        Enumeration,
        None
    }
    public RestrictionType GetRestrictionType ()
    {
        if (maEnumeration != null)
            return RestrictionType.Enumeration;
        else if (maMinimumValue!=null || maMaximumValue!=null)
            return RestrictionType.Size;
        else
            return RestrictionType.None;
    }
    
    
    
    public Iterable<T> GetEnumerationRestriction ()
    {
        return maEnumeration;
    }
    
    
    
    
    public T GetMinimum ()
    {
        return maMinimumValue;
    }

    
    
    
    public T GetMaximum ()
    {
        return maMaximumValue;
    }
    
    
    
    public boolean IsMinimumInclusive ()
    {
        return mbIsMinimumInclusive;
    }
    
    
    
    
    public boolean IsMaximumInclusive ()
    {
        return mbIsMaximumInclusive;
    }

    
    
    
    private final BuiltInType meType;
    private T maMinimumValue;
    private boolean mbIsMinimumInclusive;
    private T maMaximumValue;
    private boolean mbIsMaximumInclusive;
    private Vector<T> maEnumeration;
    private boolean mbIsList;
}