import argparse

import configparser

import datetime

import decimal

import os.path

import pathlib

from . import cache, loaders

HOME_PATH = pathlib.Path(os.path.expanduser('~'))

def currency_code(s):

    if not ((len(s) == 3) and s.isalpha()):

        raise ValueError("bad currency code: {!r}".format(s))

    return s.upper()

def currency_list(s):

    return [currency_code(code.strip()) for code in s.split(',')]

class Configuration:

    DATE_SEPS = frozenset('.-/ ')

    DEFAULT_CONFIG_PATH = pathlib.Path(HOME_PATH, '.config', 'oxrlib.ini')

    PREPOSITIONS = frozenset(['in', 'to', 'into'])

    TODAY = datetime.date.today()

    def __init__(self, arglist):

        argparser = self._build_argparser()

        self.error = argparser.error

        self.args = argparser.parse_args(arglist)

        if self.args.config_file is None:

            self.args.config_file = [self.DEFAULT_CONFIG_PATH]

        self.conffile = self._build_conffile()

        conffile_paths = [path.as_posix() for path in self.args.config_file]

            '--no-ledger',

            action='store_false', dest='ledger',

            help="Turn off an earlier --ledger setting",

        )

        hist_parser.add_argument(

            '--denomination',

            metavar='CODE', type=currency_code,

            help="In Ledger conversion output, always show rates to convert "

            "to this currency",

        )

        hist_parser.add_argument(

            '--no-denomination',

            help="Turn off an earlier --denomination setting",

        )

        hist_parser.add_argument(

            '--signed-currency', '--sign-currency',

            type=currency_code, action='append', dest='signed_currencies',

            metavar='CODE',

            help="In Ledger output, use a sign for this currency if known. "

            "Can be specified multiple times.",

        )

        hist_parser.add_argument(

            'date',

            type=self._date_from_s,

        hist_parser.add_argument(

            'word1', nargs='?', metavar='amount',

            help="Convert this amount of currency. If not specified, show rates.",

        )

        hist_parser.add_argument(

            'word2', nargs='?', metavar='first code',

            help="Convert or show rates from this currency, in three-letter code format. "

            "If not specified, show all rates on the given date.",

        )

        hist_parser.add_argument(

            'word3', nargs='?', metavar='second code',

            help="Convert or show rates to this currency, in three-letter code format. "

        )

        hist_parser.add_argument('word4', nargs='?', help=argparse.SUPPRESS)

        return prog_parser

    def _build_conffile(self):

        return configparser.ConfigParser()

    def _read_from_conffile(self, argname, sectionname, fallback, convert_to=None,

                            confname=None, getter='get', unset=None,

                            *, convert_fallback=False):

        if getattr(self.args, argname) is not unset:

        try:

            return argtype(s_value)

        except (decimal.InvalidOperation, TypeError, ValueError):

            errmsg = []

            if argname:

                errmsg.append("argument {}".format(argname))

            if typename is None:

                typename = argtype.__name__.replace('_', ' ')

            errmsg.append("invalid {} value".format(typename))

            errmsg.append(repr(s_value))

            self.error(': '.join(errmsg))

    def _post_hook_historical(self):

        year = self.args.date.year

        if year < 100:

            # Don't let the user specify ambiguous dates.

            self.error("historical data not available from year {}".format(year))

        self._read_from_conffile('base', 'Historical', 'USD', currency_code)

            self.args.denomination = None

        else:

            self._read_from_conffile('denomination', 'Historical', None, currency_code)

                                 currency_list, convert_fallback=True)

        self._read_from_conffile('ledger', 'Historical', False, getter='getboolean')

        raw_words = iter(getattr(self.args, 'word' + c) for c in '1234')

        words = iter(word for word in raw_words if word is not None)

        try:

            next_word = next(words)

            try:

                self.args.amount = decimal.Decimal(next_word)

            except decimal.InvalidOperation:

                pass

            else:

                # If an amount was given, a currency code must be given too.

                # If it wasn't, set a value that can't be parsed as a currency.

                next_word = next(words, 'none given')

            self.args.from_currency = self._convert_or_error(currency_code, next_word)

            next_word = next(words)

            if next_word.lower() in self.PREPOSITIONS:

                next_word = next(words, next_word)

            self.args.to_currency = self._convert_or_error(currency_code, next_word)

        except StopIteration:

    def _build_cache_loader(self):

        kwargs = dict(self.conffile.items('Cache'))

        try:

            kwargs['dir_path'] = pathlib.Path(kwargs.pop('directory'))

        except KeyError:

            pass

        self.cache = cache.CacheWriter(**kwargs)

        return loaders.FileCache(**kwargs)

    def _build_oxrapi_loader(self):

        kwargs = dict(self.conffile.items('OXR'))

# Write output in Ledger format.

ledger = no

# Denominate Ledger books in this currency.

# Ledger-formatted conversions will always show a rate to convert to this

# currency, even when converting between two other currencies.

# If not specified, output will show the rate for the currency you're

# converting to.

denomination = USD

# Use signs for these currencies in Ledger output.

signed_currencies = USD, EUR

import datetime

import decimal

import os

import pytest

from . import any_date, relpath

import oxrlib.cache

import oxrlib.config

import oxrlib.loaders

INI_DIR_PATH = relpath('config_ini')

def config_from(ini_filename, arglist=None):

    if arglist is None:

    config = config_from(ini_filename, arglist)

    assert config.args.base == expected_currency

@pytest.mark.parametrize('amount,from_curr,preposition,to_curr', [

    (None, 'JPY', None, None),

    (None, 'gbp', None, 'Aud'),

    (None, 'CHF', 'to', 'eur'),

    (decimal.Decimal('1000'), 'chf', None, None),

    (decimal.Decimal('999'), 'Eur', None, 'Chf'),

    (decimal.Decimal('12.34'), 'gbp', 'IN', 'eur'),

])

def test_historical_argparsing_success(amount, from_curr, preposition, to_curr, any_date):

    arglist = ['historical', any_date.isoformat()]

    arglist.extend(str(s) for s in [amount, from_curr, preposition, to_curr]

                   if s is not None)

    config = config_from(os.devnull, arglist)

    assert config.args.amount == amount

    assert config.args.from_currency == from_curr.upper()

@pytest.mark.parametrize('arglist', [

    ['100'],

    ['120', 'dollars'],

    ['to', '42', 'usd'],

    ['99', 'usd', 'minus', 'jpy'],

    ['usdjpy'],

    ['44', 'eur', 'in', 'chf', 'pronto'],

    ['eur', 'into'],

    ['50', 'jpy', 'in'],

])

def test_historical_argparsing_failure(arglist, any_date):