package org.djunits.generator;

import java.util.Arrays;
import java.util.Comparator;
import java.util.TreeMap;

import org.djunits.unit.AreaUnit;
import org.djunits.unit.Unit;
import org.djunits.unit.quantity.Quantities;
import org.djunits.unit.quantity.Quantity;
import org.djunits.unit.unitsystem.UnitSystem;
import org.djunits.unit.util.UNITS;

/**
 * Generator for the locale properties file.
 * <p>
 * @author <a href="https://www.tudelft.nl/p.knoppers">Peter Knoppers</a>
 */
public class GenerateUSLocale
{
    /**
     * Determine if a double is (very near to) a power of 10.
     * @param value double; the value to test
     * @return boolean; true if <code>value</code> is (very near to) a power of 10; false otherwise
     */
    static boolean isPowerOf10(final double value)
    {
        double log = Math.log10(value);
        double rintLog = Math.rint(log);
        boolean result = Math.abs(rintLog - log) < 0.000001;
        // System.out.println("value " + value + " is power of 10? " + result);
        return result;
    }

    /**
     * Compare two double values.
     * @param left double; the left value
     * @param right double; the right value
     * @return int; 0 if the values are equal; -1 if left should be sorted before right; +1 if right should be sorted before
     *         left
     */
    static int compareDoubles(final double left, final double right)
    {
        if (left > right)
        {
            return -1;
        }
        else if (left < right)
        {
            return 1;
        }
        return 0;
    }

    /**
     * Indicate if a unit is SI.
     * @param unit Unit&lt;?&gt;; the unit
     * @return boolean; true if the unit is SI; false otherwise
     */
    static boolean isSI(final Unit<?> unit)
    {
        return unit.getUnitSystem().equals(UnitSystem.SI_ACCEPTED) || unit.getUnitSystem().equals(UnitSystem.SI_BASE)
                || unit.getUnitSystem().equals(UnitSystem.SI_DERIVED);
    }

    /**
     * Generate the localeunit.properties file.
     * @param args String[]; the command line arguments; not used (yet)
     */
    public static void main(final String[] args)
    {
        @SuppressWarnings("unused")
        AreaUnit junk = UNITS.ACRE; // force loading of all units

        System.out.println("# Format:");
        System.out.println("# UnitType.unitname = abbreviation | description");
        System.out.println("# UnitType.unitname = abbreviation | description | text_abbreviation1 | text_abbreviation2 | ...");

        TreeMap<String, Quantity<?>> unitTypes = new TreeMap<>(Quantities.INSTANCE.getRegistry());
        for (String quantityName : unitTypes.keySet())
        {
            Quantity<?> quantity = unitTypes.get(quantityName);
            System.out.println("#");
            System.out.println("# " + quantity.getName());
            System.out.println("#");
            System.out.println(quantity.getName() + " = " + quantity.getName());
            TreeMap<String, Unit<?>> ids = new TreeMap<>(quantity.getUnitsById());
            String[] idArray = ids.keySet().toArray(new String[0]);
            Arrays.sort(idArray, new Comparator<String>()
            {
                @Override
                public int compare(String o1, String o2)
                {
                    // System.out.println("Comparing " + o1 + " to " + o2);
                    Unit<?> left = quantity.getUnitById(o1);
                    Unit<?> right = quantity.getUnitById(o2);
                    // if (left.equals(FrequencyUnit.PER_DAY) || right.equals(FrequencyUnit.PER_DAY))
                    // {
                    // System.out.println("Comparing " + o1 + " to " + o2);
                    // }
                    if (left.equals(right))
                    {
                        return o1.compareTo(o2);
                    }
                    if (left.equals(left.getQuantity().getStandardUnit()))
                    {
                        return -1;
                    }
                    if (right.equals(right.getQuantity().getStandardUnit()))
                    {
                        return 1;
                    }
                    if (isSI(left) && (!isSI(right)))
                    {
                        return -1;
                    }
                    if ((!isSI(left) && isSI(right)))
                    {
                        return 1;
                    }
                    double leftFactor = left.getScale().toStandardUnit(1.0) - left.getScale().toStandardUnit(0.0);
                    double rightFactor = right.getScale().toStandardUnit(1.0) - right.getScale().toStandardUnit(0.0);
                    if (isPowerOf10(leftFactor) && (isPowerOf10(rightFactor)))
                    {
                        return compareDoubles(leftFactor, rightFactor);
                    }
                    if (isPowerOf10(leftFactor))
                    {
                        return -1;
                    }
                    if (isPowerOf10(rightFactor))
                    {
                        return 1;
                    }
                    if (left.getName().endsWith("watt-hour") && right.getName().endsWith("watt-hour"))
                    {
                        return compareDoubles(leftFactor, rightFactor);
                    }
                    if (left.getName().endsWith("watt-hour"))
                    {
                        return -1;
                    }
                    if (right.getName().endsWith("watt-hour"))
                    {
                        return 1;
                    }
                    if (left.getName().endsWith("electronvolt") && right.getName().endsWith("electronvolt"))
                    {
                        return compareDoubles(leftFactor, rightFactor);
                    }
                    if (left.getName().endsWith("electronvolt"))
                    {
                        return -1;
                    }
                    if (right.getName().endsWith("electronvolt"))
                    {
                        return 1;
                    }
                    return left.getName().compareTo(right.getName());
                }
            });
            for (String unitId : idArray)
            {
                Unit<?> u = quantity.getUnitById(unitId);
                System.out.print(quantity.getName() + "." + u.getId() + " = "
                        + u.getDefaultDisplayAbbreviation() + " | " + u.getName());
                if (u.getAbbreviations().size() > 1)
                {
                    for (String abbreviation : u.getAbbreviations())
                    {
                        if (!abbreviation.equals(u.getDefaultDisplayAbbreviation()))
                        {
                            System.out.print(" | " + abbreviation);
                        }
                    }
                }
                System.out.println();
            }
        }
    }

}