#!/usr/bin/env python

import argparse
import os
import sys
import voltgrid

try:
    import configparser
except ImportError:
    import ConfigParser as configparser


def find_config_file():
    for location in os.curdir, os.path.expanduser('~'), os.environ.get('VOLTGRID_CFG', ''):
        if os.path.exists(os.path.join(location, '.voltgrid.cfg')):
            return location
    return False


def client():

    config = configparser.ConfigParser()

    with open(os.path.join(find_config_file(), '.voltgrid.cfg')) as cfg_file:
        config.read_file(cfg_file)

    auth = {'username': config.get('voltgrid', 'username'),
            'password': config.get('voltgrid', 'password')}
    options = {
        'base': config.get('voltgrid', 'api_host', fallback='https://api.voltgrid.com'),
        'api_version': 'api/v1'}
    return voltgrid.Client(auth=auth, options=options)


def account(args):
    verbose = args.verbose or False
    a = client().account()

    if args.actions:
        for i in a.actions().body['results']:
            if verbose:
                print(i)
            else:
                print(i)

    if args.databases:
        for i in a.databases().body['results']:
            if verbose:
                print(i)
            else:
                print(i['name'])

    if args.domains:
        for i in a.domains().body['results']:
            if verbose:
                print(i)
            else:
                print(i['name'])

    if args.ssl:
        for i in a.ssl().body['results']:
            if verbose:
                print(i)
            else:
                print(i['description'])

    if args.ssh:
        for i in a.ssh_keys().body['results']:
            if verbose:
                print(i)
            else:
                print(i['description'])

    if args.zones:
        for i in a.zones().body['results']:
            if verbose:
                print(i)
            else:
                print(i['domain'])


def domains(args):

    if args.list:
        for d in client().account().domains().body['results']:
            print(d['name'])

    if args.add:
        name = args.add
        r = client().domain(name=None).create(name=name)
        print("Result: %s: %s" % (r.code, r.body))

    if args.delete:
        name = args.delete
        r = client().domain(name=name).destroy()
        print("Result: %s: %s" % (r.code, r.body))


def zones(args):
    verbose = args.verbose or False

    if args.list:
        for d in client().account().zones().body['results']:
            if verbose:
                print(d)
            else:
                print(d['domain'])

    if args.add:
        domain = args.add
        r = client().zone(domain=None).create(domain=domain)
        print("Result: %s: %s" % (r.code, r.body))

    if args.delete:
        domain = args.delete
        r = client().zone(domain=domain).destroy()
        print("Result: %s: %s" % (r.code, r.body))

    if args.upload:
        domain = args.upload[0]
        file_path = args.upload[1]
        data = open(file_path, mode='r').read()
        options = dict()
        options['request_type'] = 'raw'
        r = client().zone(domain=domain).upload(data, options)
        print("Result: %s: %s" % (r.code, r.body))


if __name__ == "__main__":

    # Check config
    if not find_config_file():
        print('Please create .voltgrid.cfg config file.')
        sys.exit(1)

    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers(dest='')

    # Verbose option
    verbose = argparse.ArgumentParser(add_help=False)
    verbose.add_argument('-v', '--verbose', action='store_true', help='Verbose Output')

    # create the parser for the "account" command
    parser_account = subparsers.add_parser('account', parents=[verbose,])
    parser_account.add_argument('--actions', action='store_true', help='List actions')
    parser_account.add_argument('--databases', action='store_true', help='List databases')
    parser_account.add_argument('--domains', action='store_true', help='List domains')
    parser_account.add_argument('--ssl', action='store_true', help='List SSL')
    parser_account.add_argument('--ssh', action='store_true', help='List SSH')
    parser_account.add_argument('--zones', action='store_true', help='List DNS Zones')
    parser_account.set_defaults(func=account)

    # create the parser for the "domain" command
    parser_domains = subparsers.add_parser('domains',  parents=[verbose,])
    parser_domains.add_argument('-l', '--list', action='store_true', help='List domains')
    parser_domains.add_argument('-a', '--add', type=str, help='Add domain')
    parser_domains.add_argument('-d', '--delete', type=str, help='Delete domain')
    parser_domains.set_defaults(func=domains)

    # create the parser for the "zone" command
    parser_zones = subparsers.add_parser('zones',  parents=[verbose,])
    parser_zones.add_argument('-l', '--list', action='store_true', help='List zones')
    parser_zones.add_argument('-a', '--add', type=str, help='Add zone')
    parser_zones.add_argument('-d', '--delete', type=str, help='Delete zone')
    parser_zones.add_argument('-u', '--upload', nargs=2, type=str, help='Upload zone file')
    parser_zones.set_defaults(func=zones)

    # Init parser
    args = parser.parse_args()
    args.func(args)