# This file is part of LilyPond, the GNU music typesetter.
#
# Copyright (C) 1998--2020 Han-Wen Nienhuys <hanwen@xs4all.nl>
#                Jan Nieuwenhuizen <janneke@gnu.org>
#
# LilyPond is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# LilyPond is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.

import __main__
import codecs
import gettext
import glob
import optparse
import os
import re
import shutil
import sys
import time

sys.stdin = codecs.getreader('utf8')(sys.stdin.detach())
sys.stdout = codecs.getwriter('utf8')(sys.stdout.detach())
sys.stderr = codecs.getwriter('utf8')(sys.stderr.detach())

# Lilylib globals.
program_name = os.path.basename(sys.argv[0])

# Logging framework: We have the following output functions:
#    error
#    warning
#    progress
#    debug

loglevels = {"NONE": 0, "ERROR": 1, "WARN": 2,
             "BASIC": 3, "PROGRESS": 4, "INFO": 5, "DEBUG": 6}

loglevel = loglevels["PROGRESS"]


def set_loglevel(l):
    global loglevel
    newlevel = loglevels.get(l, -1)
    if newlevel > 0:
        debug_output(_("Setting loglevel to %s") % l)
        loglevel = newlevel
    else:
        error(_("Unknown or invalid loglevel '%s'") % l)


def handle_loglevel_option(option, opt_str, value, parser, *args):
    if value:
        set_loglevel(value)
    elif args:
        set_loglevel(args[0])


def is_loglevel(l):
    global loglevel
    return loglevel >= loglevels[l]


def is_verbose():
    return is_loglevel("DEBUG")


def print_logmessage(level, s, fullmessage=True, newline=True):
    if is_loglevel(level):
        if fullmessage:
            sys.stderr.write(program_name + ": " + s + '\n')
        elif newline:
            sys.stderr.write(s + '\n')
        else:
            sys.stderr.write(s)


def error(s):
    print_logmessage("ERROR", _("error: %s") % s)


def warning(s):
    print_logmessage("WARN", _("warning: %s") % s)


def progress(s, fullmessage=False, newline=True):
    print_logmessage("PROGRESS", s, fullmessage, newline)


def debug_output(s, fullmessage=False, newline=True):
    print_logmessage("DEBUG", s, fullmessage, newline)


def strip_extension(f, ext):
    (p, e) = os.path.splitext(f)
    if e == ext:
        e = ''
    return p + e


class NonDentedHeadingFormatter (optparse.IndentedHelpFormatter):
    def format_heading(self, heading):
        if heading:
            return heading[0].upper() + heading[1:] + ':\n'
        return ''

    def format_option_strings(self, option):
        sep = ' '
        if option._short_opts and option._long_opts:
            sep = ','

        metavar = ''
        if option.takes_value():
            metavar = '=%s' % option.metavar or option.dest.upper()

        return "%3s%s %s%s" % (" ".join(option._short_opts),
                               sep,
                               " ".join(option._long_opts),
                               metavar)

    # Only use one level of indentation (even for groups and nested groups),
    # since we don't indent the headeings, either
    def indent(self):
        self.current_indent = self.indent_increment
        self.level += 1

    def dedent(self):
        self.level -= 1
        if self.level <= 0:
            self.current_indent = ''
            self.level = 0

    def format_usage(self, usage):
        return _("Usage: %s") % usage + '\n'

    def format_description(self, description):
        return description


class NonEmptyOptionParser (optparse.OptionParser):
    "A subclass of OptionParser that gobbles empty string arguments."

    def parse_args(self, args=None, values=None):
        options, args = optparse.OptionParser.parse_args(self, args, values)
        return options, [_f for _f in args if _f]


def get_option_parser(*args, **kwargs):
    p = NonEmptyOptionParser(*args, **kwargs)
    p.formatter = NonDentedHeadingFormatter()
    p.formatter.set_parser(p)
    return p