// Copyright (c) 2014-2016 Thomas Fussell
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, WRISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE
//
// @license: http://www.opensource.org/licenses/mit-license.php
// @author: see AUTHORS file

#include <algorithm>
#include <cmath>

#include <detail/number_formatter.hpp>

namespace xlnt {
namespace detail {

const std::unordered_map<int, std::string> known_locales()
{
    const std::unordered_map<int, std::string> *all =
        new std::unordered_map<int, std::string>(
            {
                 { 0x401, "Arabic - Saudi Arabia" },
                 { 0x402, "Bulgarian" },
                 { 0x403, "Catalan" },
                 { 0x404, "Chinese - Taiwan" },
                 { 0x405, "Czech" },
                 { 0x406, "Danish" },
                 { 0x407, "German - Germany" },
                 { 0x408, "Greek" },
                 { 0x409, "English - United States" },
                 { 0x410, "Italian - Italy" },
                 { 0x411, "Japanese" },
                 { 0x412, "Korean" },
                 { 0x413, "Dutch - Netherlands" },
                 { 0x414, "Norwegian - Bokml" },
                 { 0x415, "Polish" },
                 { 0x416, "Portuguese - Brazil" },
                 { 0x417, "Raeto-Romance" },
                 { 0x418, "Romanian - Romania" },
                 { 0x419, "Russian" },
                 { 0x420, "Urdu" },
                 { 0x421, "Indonesian" },
                 { 0x422, "Ukrainian" },
                 { 0x423, "Belarusian" },
                 { 0x424, "Slovenian" },
                 { 0x425, "Estonian" },
                 { 0x426, "Latvian" },
                 { 0x427, "Lithuanian" },
                 { 0x428, "Tajik" },
                 { 0x429, "Farsi - Persian" },
                 { 0x430, "Sesotho (Sutu)" },
                 { 0x431, "Tsonga" },
                 { 0x432, "Setsuana" },
                 { 0x433, "Venda" },
                 { 0x434, "Xhosa" },
                 { 0x435, "Zulu" },
                 { 0x436, "Afrikaans" },
                 { 0x437, "Georgian" },
                 { 0x438, "Faroese" },
                 { 0x439, "Hindi" },
                 { 0x440, "Kyrgyz - Cyrillic" },
                 { 0x441, "Swahili" },
                 { 0x442, "Turkmen" },
                 { 0x443, "Uzbek - Latin" },
                 { 0x444, "Tatar" },
                 { 0x445, "Bengali - India" },
                 { 0x446, "Punjabi" },
                 { 0x447, "Gujarati" },
                 { 0x448, "Oriya" },
                 { 0x449, "Tamil" },
                 { 0x450, "Mongolian" },
                 { 0x451, "Tibetan" },
                 { 0x452, "Welsh" },
                 { 0x453, "Khmer" },
                 { 0x454, "Lao" },
                 { 0x455, "Burmese" },
                 { 0x456, "Galician" },
                 { 0x457, "Konkani" },
                 { 0x458, "Manipuri" },
                 { 0x459, "Sindhi" },
                 { 0x460, "Kashmiri" },
                 { 0x461, "Nepali" },
                 { 0x462, "Frisian - Netherlands" },
                 { 0x464, "Filipino" },
                 { 0x465, "Divehi; Dhivehi; Maldivian" },
                 { 0x466, "Edo" },
                 { 0x470, "Igbo - Nigeria" },
                 { 0x474, "Guarani - Paraguay" },
                 { 0x476, "Latin" },
                 { 0x477, "Somali" },
                 { 0x481, "Maori" },
                 { 0x801, "Arabic - Iraq" },
                 { 0x804, "Chinese - China" },
                 { 0x807, "German - Switzerland" },
                 { 0x809, "English - Great Britain" },
                 { 0x810, "Italian - Switzerland" },
                 { 0x813, "Dutch - Belgium" },
                 { 0x814, "Norwegian - Nynorsk" },
                 { 0x816, "Portuguese - Portugal" },
                 { 0x818, "Romanian - Moldova" },
                 { 0x819, "Russian - Moldova" },
                 { 0x843, "Uzbek - Cyrillic" },
                 { 0x845, "Bengali - Bangladesh" },
                 { 0x850, "Mongolian" },
                 { 0x1001, "Arabic - Libya" },
                 { 0x1004, "Chinese - Singapore" },
                 { 0x1007, "German - Luxembourg" },
                 { 0x1009, "English - Canada" },
                 { 0x1401, "Arabic - Algeria" },
                 { 0x1404, "Chinese - Macau SAR" },
                 { 0x1407, "German - Liechtenstein" },
                 { 0x1409, "English - New Zealand" },
                 { 0x1801, "Arabic - Morocco" },
                 { 0x1809, "English - Ireland" },
                 { 0x2001, "Arabic - Oman" },
                 { 0x2009, "English - Jamaica" },
                 { 0x2401, "Arabic - Yemen" },
                 { 0x2409, "English - Caribbean" },
                 { 0x2801, "Arabic - Syria" },
                 { 0x2809, "English - Belize" },
                 { 0x3001, "Arabic - Lebanon" },
                 { 0x3009, "English - Zimbabwe" },
                 { 0x3401, "Arabic - Kuwait" },
                 { 0x3409, "English - Phillippines" },
                 { 0x3801, "Arabic - United Arab Emirates" },
                 { 0x4001, "Arabic - Qatar" }
            });
    
    return *all;
}

bool format_condition::satisfied_by(long double number) const
{
    switch (type)
    {
    case condition_type::equal:
        return number == value;
    case condition_type::greater_or_equal:
        return number >= value;
    case condition_type::greater_than:
        return number > value;
    case condition_type::less_or_equal:
        return number <= value;
    case condition_type::less_than:
        return number < value;
    case condition_type::not_equal:
        return number != value;
    default:
        return false;
    }
}

number_format_parser::number_format_parser(const std::string &format_string)
{
    reset(format_string);
}

const std::vector<format_code> &number_format_parser::get_result() const
{
    return codes_;
}

void number_format_parser::reset(const std::string &format_string)
{
    format_string_ = format_string;
    position_ = 0;
    codes_.clear();
}

void number_format_parser::parse()
{
    auto token = parse_next_token();
    format_code section;
    template_part part;

    for (;;)
    {
        switch (token.type)
        {
        case number_format_token::token_type::end_section:
            codes_.push_back(section);
            section = format_code();

            break;

        case number_format_token::token_type::color:
            if (section.color != format_color::none
                || section.condition.type != format_condition::condition_type::none
                || section.locale != format_locale::none
                || !section.parts.empty())
            {
                throw std::runtime_error("color should be the first part of a format");
            }

            section.color = color_from_string(token.string);
            break;

        case number_format_token::token_type::locale:
        {
            if (section.locale != format_locale::none)
            {
                throw std::runtime_error("multiple locales");
            }

            auto parsed_locale = locale_from_string(token.string);
            section.locale = parsed_locale.first;

            if (!parsed_locale.second.empty())
            {
                part.type = template_part::template_type::text;
                part.string = parsed_locale.second;
                section.parts.push_back(part);
                part = template_part();
            }
            
            break;
        }

        case number_format_token::token_type::condition:
        {
            if (section.condition.type != format_condition::condition_type::none)
            {
                throw std::runtime_error("multiple conditions");
            }

            std::string value;

            if (token.string.front() == '<')
            {
                if (token.string[1] == '=')
                {
                    section.condition.type = format_condition::condition_type::less_or_equal;
                    value = token.string.substr(2);
                }
                else if (token.string[1] == '>')
                {
                    section.condition.type = format_condition::condition_type::not_equal;
                    value = token.string.substr(2);
                }
                else
                {
                    section.condition.type = format_condition::condition_type::less_than;
                    value = token.string.substr(1);
                }
            }
            else if (token.string.front() == '>')
            {
                if (token.string[1] == '=')
                {
                    section.condition.type = format_condition::condition_type::greater_or_equal;
                    value = token.string.substr(2);
                }
                else
                {
                    section.condition.type = format_condition::condition_type::greater_than;
                    value = token.string.substr(1);
                }
            }
            else if (token.string.front() == '=')
            {
                section.condition.type = format_condition::condition_type::equal;
                value = token.string.substr(1);
            }
            
            section.condition.value = std::stold(value);
            break;
        }

        case number_format_token::token_type::text:
            part.type = template_part::template_type::text;
            part.string = token.string;
            section.parts.push_back(part);
            part = template_part();

            break;
            
        case number_format_token::token_type::fill:
            part.type = template_part::template_type::fill;
            part.string = token.string;
            section.parts.push_back(part);
            part = template_part();

            break;

        case number_format_token::token_type::space:
            part.type = template_part::template_type::space;
            part.string = token.string;
            section.parts.push_back(part);
            part = template_part();

            break;
        case number_format_token::token_type::number:
            part.type = template_part::template_type::general;
            part.placeholders = parse_placeholders(token.string);
            section.parts.push_back(part);
            part = template_part();

            break;
        case number_format_token::token_type::datetime:
            section.is_datetime = true;

            switch (token.string.front())
            {
            case '[':
                section.is_timedelta = true;

                if (token.string == "[h]" || token.string == "[hh]")
                {
                    part.type = template_part::template_type::elapsed_hours;
                    break;
                }
                else if (token.string == "[m]" || token.string == "[mm]")
                {
                    part.type = template_part::template_type::elapsed_minutes;
                    break;
                }
                else if (token.string == "[s]" || token.string == "[ss]")
                {
                    part.type = template_part::template_type::elapsed_seconds;
                    break;
                }
            case 'm':
                if (token.string == "m")
                {
                    part.type = template_part::template_type::month_number;
                    break;
                }
                else if (token.string == "mm")
                {
                    part.type = template_part::template_type::month_number_leading_zero;
                    break;
                }
                else if (token.string == "mmm")
                {
                    part.type = template_part::template_type::month_abbreviation;
                    break;
                }
                else if (token.string == "mmmm")
                {
                    part.type = template_part::template_type::month_name;
                    break;
                }
                else if (token.string == "mmmmm")
                {
                    part.type = template_part::template_type::month_letter;
                    break;
                }
            case 'd':
                if (token.string == "d")
                {
                    part.type = template_part::template_type::day_number;
                    break;
                }
                else if (token.string == "dd")
                {
                    part.type = template_part::template_type::day_number_leading_zero;
                    break;
                }
                else if (token.string == "ddd")
                {
                    part.type = template_part::template_type::day_abbreviation;
                    break;
                }
                else if (token.string == "dddd")
                {
                    part.type = template_part::template_type::day_name;
                    break;
                }
            case 'y':
                if (token.string == "yy")
                {
                    part.type = template_part::template_type::year_short;
                    break;
                }
                else if (token.string == "yyyy")
                {
                    part.type = template_part::template_type::year_long;
                    break;
                }
            case 'h':
                if (token.string == "h")
                {
                    part.type = template_part::template_type::hour;
                    break;
                }
                else if (token.string == "hh")
                {
                    part.type = template_part::template_type::hour_leading_zero;
                    break;
                }
            case 's':
                if (token.string == "s")
                {
                    part.type = template_part::template_type::second;
                    break;
                }
                else if (token.string == "ss")
                {
                    part.type = template_part::template_type::second_leading_zero;
                    break;
                }
            case 'A':
                section.twelve_hour = true;

                if (token.string == "AM/PM")
                {
                    part.type = template_part::template_type::am_pm;
                    break;
                }
                else if (token.string == "A/P")
                {
                    part.type = template_part::template_type::a_p;
                    break;
                }
            }

            section.parts.push_back(part);
            part = template_part();
            
            break;
            
        case number_format_token::token_type::end:
            codes_.push_back(section);
            finalize();

            return;
            
        default:
            break;
        }

        token = parse_next_token();
    }

    throw std::runtime_error("bad format");
}

void number_format_parser::finalize()
{
    for (auto &code : codes_)
    {
        bool fix = false;
        bool leading_zero = false;
        std::size_t minutes_index = 0;

        bool integer_part = false;
        bool fractional_part = false;
        std::size_t integer_part_index = 0;

        bool percentage = false;

        bool exponent = false;
        std::size_t exponent_index = 0;

        bool fraction = false;
        std::size_t fraction_denominator_index = 0;
        std::size_t fraction_numerator_index = 0;
        
        bool seconds = false;
        bool fractional_seconds = false;
        std::size_t seconds_index = 0;

        for (std::size_t i = 0; i < code.parts.size(); ++i)
        {
            const auto &part = code.parts[i];
            
            if (i > 0
                && i + 1 < code.parts.size()
                && part.type == template_part::template_type::text
                && part.string == "/"
                && code.parts[i - 1].placeholders.type == format_placeholders::placeholders_type::integer_part
                && code.parts[i + 1].placeholders.type == format_placeholders::placeholders_type::integer_part)
            {
                fraction = true;
                fraction_numerator_index = i - 1;
                fraction_denominator_index = i + 1;
            }

            if (part.placeholders.type == format_placeholders::placeholders_type::integer_part)
            {
                integer_part = true;
                integer_part_index = i;
            }
            else if (part.placeholders.type == format_placeholders::placeholders_type::fractional_part)
            {
                fractional_part = true;
            }
            else if (part.placeholders.type == format_placeholders::placeholders_type::scientific_exponent_plus
                || part.placeholders.type == format_placeholders::placeholders_type::scientific_exponent_minus)
            {
                exponent = true;
                exponent_index = i;
            }

            if (part.placeholders.percentage)
            {
                percentage = true;
            }
            
            if (part.type == template_part::template_type::second
                || part.type == template_part::template_type::second_leading_zero)
            {
                seconds = true;
                seconds_index = i;
            }

            if (seconds && part.placeholders.type == format_placeholders::placeholders_type::fractional_part)
            {
                fractional_seconds = true;
            }

            if (part.type == template_part::template_type::month_number
                || part.type == template_part::template_type::month_number_leading_zero)
            {
                if (code.parts.size() > 1 && i < code.parts.size() - 2)
                {
                    const auto &next = code.parts[i + 1];
                    const auto &after_next = code.parts[i + 2];

                    if ((next.type == template_part::template_type::second
                        || next.type == template_part::template_type::second_leading_zero)
                        || (next.type == template_part::template_type::text
                        && next.string == ":"
                        && (after_next.type == template_part::template_type::second ||
                            after_next.type == template_part::template_type::second_leading_zero)))
                    {
                        fix = true;
                        leading_zero = part.type == template_part::template_type::month_number_leading_zero;
                        minutes_index = i;
                    }
                }

                if (!fix && i > 1)
                {
                    const auto &previous = code.parts[i - 1];
                    const auto &before_previous = code.parts[i - 2];

                    if (previous.type == template_part::template_type::text
                        && previous.string == ":"
                        && (before_previous.type == template_part::template_type::hour ||
                            before_previous.type == template_part::template_type::hour_leading_zero))
                    {
                        fix = true;
                        leading_zero = part.type == template_part::template_type::month_number_leading_zero;
                        minutes_index = i;
                    }
                }
            }
        }
        
        if (fix)
        {
            code.parts[minutes_index].type = leading_zero ?
                template_part::template_type::minute_leading_zero :
                template_part::template_type::minute;
        }

        if (integer_part && !fractional_part)
        {
            code.parts[integer_part_index].placeholders.type =
                format_placeholders::placeholders_type::integer_only;
        }

        if (integer_part && fractional_part && percentage)
        {
            code.parts[integer_part_index].placeholders.percentage = true;
        }
        
        if (exponent)
        {
            const auto &next = code.parts[exponent_index + 1];
            auto temp = code.parts[exponent_index].placeholders.type;
            code.parts[exponent_index].placeholders = next.placeholders;
            code.parts[exponent_index].placeholders.type = temp;
            code.parts.erase(code.parts.begin() + exponent_index + 1);

            for (std::size_t i = 0; i < code.parts.size(); ++i)
            {
                code.parts[i].placeholders.scientific = true;
            }
        }
        
        if (fraction)
        {
            code.parts[fraction_numerator_index].placeholders.type =
                format_placeholders::placeholders_type::fraction_numerator;
            code.parts[fraction_denominator_index].placeholders.type =
                format_placeholders::placeholders_type::fraction_denominator;
            
            for (std::size_t i = 0; i < code.parts.size(); ++i)
            {
                if (code.parts[i].placeholders.type ==
                    format_placeholders::placeholders_type::integer_part)
                {
                    code.parts[i].placeholders.type =
                        format_placeholders::placeholders_type::fraction_integer;
                }
            }
        }
        
        if (fractional_seconds)
        {
            if (code.parts[seconds_index].type == template_part::template_type::second)
            {
                code.parts[seconds_index].type = template_part::template_type::second_fractional;
            }
            else
            {
                code.parts[seconds_index].type = template_part::template_type::second_leading_zero_fractional;
            }
        }
    }

    validate();
}

number_format_token number_format_parser::parse_next_token()
{
    number_format_token token;

    if (format_string_.size() <= position_)
    {
        token.type = number_format_token::token_type::end;
        return token;
    }

    auto current_char = format_string_[position_++];

    switch (current_char)
    {
    case '[':
        if (position_ == format_string_.size())
        {
            throw std::runtime_error("missing ]");
        }

        if (format_string_[position_] == ']')
        {
            throw std::runtime_error("empty []");
        }

        do
        {
            token.string.push_back(format_string_[position_++]);
        }
        while (position_ < format_string_.size() && format_string_[position_] != ']');

        if (token.string[0] == '<' || token.string[0] == '>' || token.string[0] == '=')
        {
            token.type = number_format_token::token_type::condition;
        }
        else if (token.string[0] == '$')
        {
            token.type = number_format_token::token_type::locale;
        }
        else if (token.string.size() <= 2 &&
            ((token.string == "h" || token.string == "hh") ||
            (token.string == "m" || token.string == "mm") ||
            (token.string == "s" || token.string == "ss")))
        {
            token.type = number_format_token::token_type::datetime;
            token.string = "[" + token.string + "]";
        }
        else
        {
            token.type = number_format_token::token_type::color;
            color_from_string(token.string);
        }

        ++position_;

        break;

    case '\\':
        token.type = number_format_token::token_type::text;
        token.string.push_back(format_string_[position_++]);

        break;

    case 'G':
        if (format_string_.substr(position_ - 1, 7) != "General")
        {
            throw std::runtime_error("expected General");
        }

        token.type = number_format_token::token_type::number;
        token.string = "General";
        position_ += 6;

        break;

    case '_':
        token.type = number_format_token::token_type::space;
        token.string.push_back(format_string_[position_++]);

        break;

    case '*':
        token.type = number_format_token::token_type::fill;
        token.string.push_back(format_string_[position_++]);

        break;

    case '0':
    case '#':
    case '?':
    case '.':
        token.type = number_format_token::token_type::number;

        do
        {
            token.string.push_back(current_char);
            current_char = format_string_[position_++];
        }
        while (current_char == '0' || current_char == '#' || current_char == '?' || current_char == ',');

        --position_;

        if (current_char == '%')
        {
            token.string.push_back('%');
            ++position_;
        }

        break;
        
    case 'y':
    case 'm':
    case 'd':
    case 'h':
    case 's':
        token.type = number_format_token::token_type::datetime;
        token.string.push_back(current_char);
        
        while (format_string_[position_] == current_char)
        {
            token.string.push_back(current_char);
            ++position_;
        }

        break;

    case 'A':
        token.type = number_format_token::token_type::datetime;

        if (format_string_.substr(position_ - 1, 5) == "AM/PM")
        {
            position_ += 4;
            token.string = "AM/PM";
        }
        else if (format_string_.substr(position_ - 1, 3) == "A/P")
        {
            position_ += 2;
            token.string = "A/P";
        }
        else
        {
            throw std::runtime_error("expected AM/PM or A/P");
        }

        break;

    case '"':
    {
        token.type = number_format_token::token_type::text;
        auto start = position_;
        auto end = format_string_.find('"', position_);

        while (end != std::string::npos && format_string_[end - 1] == '\\')
        {
            token.string.append(format_string_.substr(start, end - start - 1));
            token.string.push_back('"');
            position_ = end + 1;
            start = position_;
            end = format_string_.find('"', position_);
        }

        if (end != start)
        {
            token.string.append(format_string_.substr(start, end - start));
        }

        position_ = end + 1;

        break;
    }

    case ';':
        token.type = number_format_token::token_type::end_section;
        break;
        
    case '(':
    case ')':
    case '-':
    case '+':
    case ':':
    case ' ':
    case '/':
        token.type = number_format_token::token_type::text;
        token.string.push_back(current_char);

        break;
        
    case '@':
        token.type = number_format_token::token_type::number;
        token.string.push_back(current_char);
        break;
        
    case 'E':
        token.type = number_format_token::token_type::number;
        token.string.push_back(current_char);
        current_char = format_string_[position_++];
        
        if (current_char == '+' || current_char == '-')
        {
            token.string.push_back(current_char);
            break;
        }

    default:
        throw std::runtime_error("unexpected character");
    }

    return token;
}

void number_format_parser::validate()
{
    if (codes_.size() > 4)
    {
        throw std::runtime_error("too many format codes");
    }

    if (codes_.size() > 2)
    {
        if (codes_[0].condition.type != format_condition::condition_type::none &&
            codes_[1].condition.type != format_condition::condition_type::none &&
            codes_[2].condition.type != format_condition::condition_type::none)
        {
            throw std::runtime_error("format should have a maximum of two codes with conditions");
        }
    }
}

format_placeholders number_format_parser::parse_placeholders(const std::string &placeholders_string)
{
    format_placeholders p;

    if (placeholders_string == "General")
    {
        p.type = format_placeholders::placeholders_type::general;
        return p;
    }
    else if (placeholders_string == "@")
    {
        p.type = format_placeholders::placeholders_type::text;
        return p;
    }
    else if (placeholders_string.front() == '.')
    {
        p.type = format_placeholders::placeholders_type::fractional_part;
    }
    else if (placeholders_string.front() == 'E')
    {
        p.type = placeholders_string[1] == '+'
            ? format_placeholders::placeholders_type::scientific_exponent_plus
            : format_placeholders::placeholders_type::scientific_exponent_minus;
        return p;
    }
    else
    {
        p.type = format_placeholders::placeholders_type::integer_part;
    }

    if (placeholders_string.back() == '%')
    {
        p.percentage = true;
    }

    std::vector<std::size_t> comma_indices;

    for (std::size_t i = 0; i < placeholders_string.size(); ++i)
    {
        auto c = placeholders_string[i];

        if (c == '0')
        {
            ++p.num_zeros;
        }
        else if (c == '#')
        {
            ++p.num_optionals;
        }
        else if (c == '?')
        {
            ++p.num_spaces;
        }
        else if (c == ',')
        {
            comma_indices.push_back(i);
        }
    }
    
    if (!comma_indices.empty())
    {
        std::size_t i = placeholders_string.size() - 1;

        while (!comma_indices.empty() && i == comma_indices.back())
        {
            ++p.thousands_scale;
            --i;
            comma_indices.pop_back();
        }
        
        p.use_comma_separator = !comma_indices.empty();
    }
    
    return p;
}

format_color number_format_parser::color_from_string(const std::string &color)
{
    switch (color[0])
    {
    case 'C':
        if (color == "Cyan")
        {
            return format_color::cyan;
        }
        else if (color.substr(0, 5) == "Color")
        {
            auto color_number = std::stoull(color.substr(5));

            if (color_number >= 1 && color_number <= 56)
            {
                return static_cast<format_color>(color_number);
            }
        }
    case 'B':
        if (color == "Black")
        {
            return format_color::black;
        }
        else if (color == "Blue")
        {
            return format_color::blue;
        }
    case 'G':
        if (color == "Green")
        {
            return format_color::green;
        }
    case 'W':
        if (color == "White")
        {
            return format_color::white;
        }
    case 'M':
        if (color == "Magenta")
        {
            return format_color::magenta;
        }
    case 'Y':
        if (color == "Yellow")
        {
            return format_color::yellow;
        }
    case 'R':
        if (color == "Red")
        {
            return format_color::red;
        }
    default:
        throw std::runtime_error("bad color: " + color);
    }
}

std::pair<format_locale, std::string> number_format_parser::locale_from_string(const std::string &locale_string)
{
    auto hyphen_index = locale_string.find('-');

    if (locale_string.empty() || locale_string.front() != '$' || hyphen_index == std::string::npos)
    {
        throw std::runtime_error("bad locale: " + locale_string);
    }

    std::pair<format_locale, std::string> result;

    if (hyphen_index > 1)
    {
        result.second = locale_string.substr(1, hyphen_index - 1);
    }

    auto country_code_string = locale_string.substr(hyphen_index + 1);

    if (country_code_string.empty())
    {
        throw std::runtime_error("bad locale: " + locale_string);
    }
    
    for (auto c : country_code_string)
    {
        if (!((c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f') || (c >= '0' && c <= '9')))
        {
            throw std::runtime_error("bad locale: " + locale_string);
        }
    }

    auto country_code = std::stoi(country_code_string, nullptr, 16);

    for (const auto &known_locale : known_locales())
    {
        if (known_locale.first == country_code)
        {
            result.first = static_cast<format_locale>(country_code);
            return result;
        }
    }

    throw std::runtime_error("unknown country code: " + country_code_string);
}

number_formatter::number_formatter(const std::string &format_string, xlnt::calendar calendar)
    : parser_(format_string),
      calendar_(calendar)
{
    parser_.parse();
    format_ = parser_.get_result();
}

std::string number_formatter::format_number(long double number)
{
    if (format_[0].condition.type != format_condition::condition_type::none)
    {
        if (format_[0].condition.satisfied_by(number))
        {
            return format_number(format_[0], number);
        }

        if (format_.size() == 1)
        {
            return std::string(11, '#');
        }
        
        if (format_[1].condition.type == format_condition::condition_type::none
            || format_[1].condition.satisfied_by(number))
        {
            return format_number(format_[1], number);
        }
        
        if (format_.size() == 2)
        {
            return std::string(11, '#');
        }
        
        return format_number(format_[2], number);
    }
    
    // no conditions, format based on sign:

    // 1 section, use for all
    if (format_.size() == 1)
    {
        return format_number(format_[0], number);
    }
    // 2 sections, first for positive and zero, second for negative
    else if (format_.size() == 2)
    {
        if (number >= 0)
        {
            return format_number(format_[0], number);
        }
        else
        {
            return format_number(format_[1], std::fabs(number));
        }
    }
    // 3+ sections, first for positive, second for negative, third for zero
    else
    {
        if (number > 0)
        {
            return format_number(format_[0], number);
        }
        else if (number < 0)
        {
            return format_number(format_[1], std::fabs(number));
        }
        else
        {
            return format_number(format_[2], number);
        }
    }
}

std::string number_formatter::format_text(const std::string &text)
{
    if (format_.size() < 4)
    {
        format_code temp;
        template_part temp_part;
        temp_part.type = template_part::template_type::general;
        temp_part.placeholders.type = format_placeholders::placeholders_type::general;
        temp.parts.push_back(temp_part);
        return format_text(temp, text);
    }

    return format_text(format_[3], text);
}

std::string number_formatter::fill_placeholders(const format_placeholders &p, long double number)
{
    if (p.type == format_placeholders::placeholders_type::general
        || p.type == format_placeholders::placeholders_type::text)
    {
        auto result = std::to_string(number);

        while (result.back() == '0')
        {
            result.pop_back();
        }

        if (result.back() == '.')
        {
            result.pop_back();
        }

        return result;
    }

    if (p.percentage)
    {
        number *= 100;
    }

    if (p.thousands_scale > 0)
    {
        number /= std::pow(1000, p.thousands_scale);
    }

    auto integer_part = static_cast<int>(number);

    switch (p.type)
    {
    case format_placeholders::placeholders_type::integer_only:
    case format_placeholders::placeholders_type::integer_part:
    case format_placeholders::placeholders_type::fraction_integer:
    {
        auto result = std::to_string(integer_part);
        
        while (result.size() < p.num_zeros)
        {
            result = "0" + result;
        }
        
        while (result.size() < p.num_zeros + p.num_spaces)
        {
            result = " " + result;
        }
        
        if (p.use_comma_separator)
        {
            std::vector<char> digits(result.rbegin(), result.rend());
            std::string temp;
            
            for (std::size_t i = 0; i < digits.size(); i++)
            {
                temp.push_back(digits[i]);

                if (i % 3 == 2)
                {
                    temp.push_back(',');
                }
            }
            
            result = std::string(temp.rbegin(), temp.rend());
        }

        if (p.percentage && p.type == format_placeholders::placeholders_type::integer_only)
        {
            result.push_back('%');
        }

        return result;
    }

    case format_placeholders::placeholders_type::fractional_part:
    {
        auto fractional_part = number - integer_part;
        auto result = fractional_part == 0 ? std::string(".") : std::to_string(fractional_part).substr(1);

        while (result.back() == '0' || result.size() > (p.num_zeros + p.num_optionals + 1))
        {
            result.pop_back();
        }

        while (result.size() < p.num_zeros + 1)
        {
            result.push_back('0');
        }

        while (result.size() < p.num_zeros + p.num_spaces + 1)
        {
            result.push_back(' ');
        }

        if (p.percentage)
        {
            result.push_back('%');
        }

        return result;
    }

    default:
        return "";
    }
}

std::string number_formatter::fill_scientific_placeholders(const format_placeholders &integer_part,
        const format_placeholders &fractional_part, const format_placeholders &exponent_part,
        long double number)
{
    std::size_t logarithm = 0;
    
    if (number != 0)
    {
        logarithm = static_cast<int>(std::log10(number));

        if (integer_part.num_zeros + integer_part.num_optionals > 1)
        {
            logarithm = integer_part.num_zeros + integer_part.num_optionals;
        }
    }

    number /= std::pow(10, logarithm);
    
    auto integer = static_cast<int>(number);
    auto fraction = number - integer;

    std::string integer_string = std::to_string(integer);

    if (number == 0)
    {
        integer_string = std::string(integer_part.num_zeros + integer_part.num_optionals, '0');
    }

    std::string fractional_string = std::to_string(fraction).substr(1);

    while (fractional_string.size() > fractional_part.num_zeros + fractional_part.num_optionals + 1)
    {
        fractional_string.pop_back();
    }

    std::string exponent_string = std::to_string(logarithm);

    while (exponent_string.size() < fractional_part.num_zeros)
    {
        exponent_string.insert(0, "0");
    }

    if (exponent_part.type == format_placeholders::placeholders_type::scientific_exponent_plus)
    {
        exponent_string.insert(0, "E+");
    }
    else
    {
        exponent_string.insert(0, "E");
    }

    return integer_string + fractional_string + exponent_string;
}

std::string number_formatter::fill_fraction_placeholders(const format_placeholders &numerator,
    const format_placeholders &denominator, long double number, bool improper)
{
    auto fractional_part = number - static_cast<int>(number);
    auto original_fractional_part = fractional_part;
    fractional_part *= 10;

    while (std::abs(fractional_part - static_cast<int>(fractional_part)) > 0.000001
        && std::abs(fractional_part - static_cast<int>(fractional_part)) < 0.999999)
    {
        fractional_part *= 10;
    }

    fractional_part = static_cast<int>(fractional_part);
    auto denominator_digits = denominator.num_zeros + denominator.num_optionals + denominator.num_spaces;
//    auto denominator_digits = static_cast<std::size_t>(std::ceil(std::log10(fractional_part)));

    auto lower = static_cast<int>(std::pow(10, denominator_digits - 1));
    auto upper = static_cast<int>(std::pow(10, denominator_digits));
    auto best_denominator = lower;
    auto best_difference = 1000.0L;

    for (int i = lower; i < upper; ++i)
    {
        auto numerator_full = original_fractional_part * i;
        auto numerator_rounded = static_cast<int>(std::round(numerator_full));
        auto difference = std::fabs(original_fractional_part - (numerator_rounded / static_cast<long double>(i)));
        
        if (difference < best_difference)
        {
            best_difference = difference;
            best_denominator = i;
        }
    }

    auto numerator_rounded = static_cast<int>(std::round(original_fractional_part * best_denominator));
    return std::to_string(numerator_rounded) + "/" + std::to_string(best_denominator);
}

std::string number_formatter::format_number(const format_code &format, long double number)
{
    static const std::vector<std::string> *month_names =
    new std::vector<std::string>
    {
        "January",
        "February",
        "March",
        "April",
        "May",
        "June",
        "July",
        "August",
        "September",
        "October",
        "November",
        "December"
    };

    static const std::vector<std::string> *day_names =
    new std::vector<std::string>
    {
        "Sunday",
        "Monday",
        "Tuesday",
        "Wednesday",
        "Thursday",
        "Friday",
        "Saturday"
    };
    
    std::string result;

    if (number < 0)
    {
        result.push_back('-');

        if (format.is_datetime)
        {
            return std::string(11, '#');
        }
    }

    number = std::fabs(number);

    xlnt::datetime dt(0, 1, 0);
    std::size_t hour = 0;

    if (format.is_datetime)
    {
        if (number != 0)
        {
            dt = xlnt::datetime::from_number(number, calendar_);
        }

        hour = dt.hour;

        if (format.twelve_hour)
        {
            hour %= 12;

            if (hour == 0)
            {
                hour = 12;
            }
        }
    }
    
    bool improper_fraction = true;
    std::size_t fill_index = 0;
    bool fill = false;
    std::string fill_character;

    for (std::size_t i = 0; i < format.parts.size(); ++i)
    {
        const auto &part = format.parts[i];

        switch (part.type)
        {
        case template_part::template_type::space:
            result.push_back(' ');
            break;
        case template_part::template_type::text:
            result.append(part.string);
            break;

        case template_part::template_type::fill:
            fill = true;
            fill_index = result.size();
            fill_character = part.string;
            break;
        case template_part::template_type::general:
        {
            if (part.placeholders.type == format_placeholders::placeholders_type::fractional_part
                && (format.is_datetime || format.is_timedelta))
            {
                auto digits = std::min(static_cast<std::size_t>(6), part.placeholders.num_zeros + part.placeholders.num_optionals);
                auto denominator = static_cast<int>(std::pow(10.0, digits));
                auto fractional_seconds = dt.microsecond / 1.0E6 * denominator;
                fractional_seconds = std::round(fractional_seconds) / denominator;
                result.append(fill_placeholders(part.placeholders, fractional_seconds));
                break;
            }

            if (part.placeholders.type == format_placeholders::placeholders_type::fraction_integer)
            {
                improper_fraction = false;
            }

            if (part.placeholders.type == format_placeholders::placeholders_type::fraction_numerator)
            {
                i += 2;

                if (number == 0)
                {
                    result.pop_back();
                    break;
                }

                result.append(fill_fraction_placeholders(part.placeholders, format.parts[i].placeholders, number, improper_fraction));
            }
            else if (part.placeholders.scientific && part.placeholders.type == format_placeholders::placeholders_type::integer_part)
            {
                auto integer_part = part.placeholders;
                ++i;
                auto fractional_part = format.parts[i++].placeholders;
                auto exponent_part = format.parts[i++].placeholders;
                result.append(fill_scientific_placeholders(integer_part, fractional_part, exponent_part, number));
            }
            else
            {
                result.append(fill_placeholders(part.placeholders, number));
            }

            break;
        }
        case template_part::template_type::day_number:
            result.append(std::to_string(dt.day));
            break;
        case template_part::template_type::day_number_leading_zero:
            if (dt.day < 10)
            {
                result.push_back('0');
            }

            result.append(std::to_string(dt.day));
            break;
        case template_part::template_type::month_abbreviation:
            result.append(month_names->at(dt.month - 1).substr(0, 3));
            break;
        case template_part::template_type::month_name:
            result.append(month_names->at(dt.month - 1));
            break;
        case template_part::template_type::month_number:
            result.append(std::to_string(dt.month));
            break;
        case template_part::template_type::month_number_leading_zero:
            if (dt.month < 10)
            {
                result.push_back('0');
            }

            result.append(std::to_string(dt.month));
            break;
        case template_part::template_type::year_short:
            if (dt.year % 1000 < 10)
            {
                result.push_back('0');
            }

            result.append(std::to_string(dt.year % 1000));
            break;
        case template_part::template_type::year_long:
            result.append(std::to_string(dt.year));
            break;
        case template_part::template_type::hour:
            result.append(std::to_string(hour));
            break;
        case template_part::template_type::hour_leading_zero:
            if (hour < 10)
            {
                result.push_back('0');
            }

            result.append(std::to_string(hour));
            break;
        case template_part::template_type::minute:
            result.append(std::to_string(dt.minute));
            break;
        case template_part::template_type::minute_leading_zero:
            if (dt.minute < 10)
            {
                result.push_back('0');
            }

            result.append(std::to_string(dt.minute));
            break;
        case template_part::template_type::second:
            result.append(std::to_string(dt.second + (dt.microsecond > 500000 ? 1 : 0)));
            break;
        case template_part::template_type::second_fractional:
            result.append(std::to_string(dt.second));
            break;
        case template_part::template_type::second_leading_zero:
            if ((dt.second + (dt.microsecond > 500000 ? 1 : 0)) < 10)
            {
                result.push_back('0');
            }

            result.append(std::to_string(dt.second + (dt.microsecond > 500000 ? 1 : 0)));
            break;
        case template_part::template_type::second_leading_zero_fractional:
            if (dt.second < 10)
            {
                result.push_back('0');
            }

            result.append(std::to_string(dt.second));
            break;
        case template_part::template_type::am_pm:
            if (dt.hour < 12)
            {
                result.append("AM");
            }
            else
            {
                result.append("PM");
            }

            break;

        case template_part::template_type::a_p:
            if (dt.hour < 12)
            {
                result.append("A");
            }
            else
            {
                result.append("P");
            }

            break;

        case template_part::template_type::elapsed_hours:
            result.append(std::to_string(24 * static_cast<int>(number) + dt.hour));
            break;

        case template_part::template_type::elapsed_minutes:
            result.append(std::to_string(24 * 60 * static_cast<int>(number) + (60 * dt.hour) + dt.minute));
            break;

        case template_part::template_type::elapsed_seconds:
            result.append(std::to_string(24 * 60 * 60 * static_cast<int>(number) + (60 * 60 * dt.hour) + (60 * dt.minute) + dt.second));
            break;

        case template_part::template_type::month_letter:
            result.append(month_names->at(dt.month - 1).substr(0, 1));
            break;

        case template_part::template_type::day_abbreviation:
            result.append(day_names->at(dt.weekday() - 1).substr(0, 3));
            break;

        case template_part::template_type::day_name:
            result.append(day_names->at(dt.weekday() - 1));
            break;

        case template_part::template_type::bad:
            throw std::runtime_error("bad format");
        }
    }
    
    const std::size_t width = 11;
    
    if (fill && result.size() < width)
    {
        auto remaining = width - result.size();

        std::string fill_string(remaining, fill_character.front());
        // TODO: A UTF-8 character could be multiple bytes

        result = result.substr(0, fill_index) + fill_string + result.substr(fill_index);
    }

    return result;
}

std::string number_formatter::format_text(const format_code &format, const std::string &text)
{
    std::string result;
    bool any_text_part = false;

    for (const auto &part : format.parts)
    {
        switch (part.type)
        {
        case template_part::template_type::text:
            result.append(part.string);
            any_text_part = true;
            break;

        case template_part::template_type::general:
            if (part.placeholders.type == format_placeholders::placeholders_type::general
                || part.placeholders.type == format_placeholders::placeholders_type::text)
            {
                result.append(text);
                any_text_part = true;
            }

            break;

        default:
            break;
        }
    }

    if (!format.parts.empty() && !any_text_part)
    {
        return text;
    }

    return result;
}

} // namespace detail
} // namespace xlnt