import datetime
import json
import argparse
import logging

import requests
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
from timestamper import rpcurl_from_config

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s [%(levelname)s] %(message)s')

class NamecoinStore(object):
    identity = None

    def __init__(self, url='http://127.0.0.1:8336', identity=None):
        self.client = AuthServiceProxy(url)
        self.identity = identity

    def set(self, key, value):
        name = self.identity.format(key)
        data = json.dumps(value)

        reg_txid, nonce = self.client.name_new(name)
        logging.debug('reg_txid, nonce: %r %r', reg_txid, nonce)
        txid = self.client.name_firstupdate(name, nonce, reg_txid, data)
        logging.debug('txid: %r', txid)
        return txid

    def get(self, key):
        try:
            hist = self.client.name_history(self.identity.format(key))
        except JSONRPCException as exc:
            # FIXME maybe?
            if str(exc).split(': ')[0] == '-4':
                logging.exception('No record found')
                return None

            raise

        last_tx = self.client.gettransaction(hist[-1]['txid'])

        return {
            'history': hist,
            'last_tx': last_tx
            }

def bind_parser(p):
    def deco(func):
        p.set_defaults(func=func)
        return func
    return deco

parser = argparse.ArgumentParser()
parser.add_argument('--rpc', help='namecoind RPC URL (defaults to data obtained from ~/.namecoin.conf)')
sub = parser.add_subparsers()

verify_parser = sub.add_parser('verify', help='lookup KRS database')
verify_parser.add_argument('id', help='lookup ID')

@bind_parser(verify_parser)
def verify(args, store):
    print(store.get(args.id))

publish_parser = sub.add_parser('publish', help='publish mojepanstwo.pl data')
publish_parser.add_argument('--limit', type=int, help='limit number of records', default=20)
publish_parser.add_argument('--page', type=int, help='start with specified page', default=1)
publish_parser.add_argument('--skip', type=int, help='skip first N records', default=0)
publish_parser.add_argument('--search', help='search query (example: krs_podmioty.nip=1234567)')
publish_parser.add_argument('-n', '--dry-run', action='store_true', help='only parse data')

@bind_parser(publish_parser)
def publish(args, store):
    query =  {
        'limit': args.limit,
        'page': args.page,
        }

    if args.search:
        k, _, v = args.search.partition('=')
        query['conditions[%s]' % k] = v

    data = requests.get('https://api-v3.mojepanstwo.pl/dane/krs_podmioty.json', query).json()
    logging.info('Total objects: %d, selected: %d', data['Count'], len(data['Dataobject']))

    output = {}
    for obj in data['Dataobject'][args.skip:]:
        if obj['data']['krs_podmioty.nip'] == '0':
            logging.info('Ignoring %s (no NIP/VATID)', obj['mp_url'])
            continue
        k = obj['data']['krs_podmioty.nip']

        output[k] = obj['mp_url']
        logging.info('%s => %r', k, output[k])

    logging.info('Gathered %d records', len(output))

    if args.dry_run:
        logging.info('Dry run, not publishing')
        return

    for k, v in output.items():
        logging.info('Publishing %s => %r', k, v)
        store.set(k, v)


def main():
    args = parser.parse_args()
    store = NamecoinStore(
        args.rpc or rpcurl_from_config('namecoin', ''),
        'krs-test/{}')
    args.func(args, store)

if __name__ == "__main__":
    main()