:author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program 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.

#

# This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

from __future__ import with_statement

import os

import sys

import random

import urllib2

import pprint

import argparse

try:

    from rhodecode.lib.ext_json import json

except ImportError:

    try:

        import simplejson as json

    except ImportError:

        import json

CONFIG_NAME = '.rhodecode'

FORMAT_PRETTY = 'pretty'

FORMAT_JSON = 'json'

class RcConf(object):

    """

    RhodeCode config for API

    conf = RcConf()

    conf['key']

    """

        self._conf = {}

        if autocreate:

            self.make_config(config)

        if autoload:

            self._conf = self.load_config()

    def __getitem__(self, key):

        return self._conf[key]

    def __nonzero__(self):

        if self._conf:

            return True

        return False

    def __eq__(self):

        return self._conf.__eq__()

    def __repr__(self):

        return 'RcConf<%s>' % self._conf.__repr__()

    def make_config(self, config):

        """

        Saves given config as a JSON dump in the _conf_name location

        :param config:

        :type config:

        """

        with open(self._conf_name, 'wb') as f:

            json.dump(config, f, indent=4)

    def update_config(self, new_config):

        """

        Reads the JSON config updates it's values with new_config and

        saves it back as JSON dump

        :param new_config:

        """

        config = {}

        try:

            with open(self._conf_name, 'rb') as conf:

                config = json.load(conf)

        except IOError, e:

            sys.stderr.write(str(e) + '\n')

        config.update(new_config)

        self.make_config(config)

    def load_config(self):

        """

        Loads config from file and returns loaded JSON object

        """

        try:

            with open(self._conf_name, 'rb') as conf:

                return  json.load(conf)

        except IOError, e:

            #sys.stderr.write(str(e) + '\n')

            pass

def api_call(apikey, apihost, format, method=None, **kw):

    """

    Api_call wrapper for RhodeCode

    :param apikey:

    :param apihost:

    :param format: formatting, pretty means prints and pprint of json

     json returns unparsed json

    :param method:

    """

    def _build_data(random_id):

        """

        Builds API data with given random ID

        :param random_id:

        :type random_id:

        """

        return {

            "id": random_id,

            "api_key": apikey,

            "method": method,

            "args": kw

        }

    if not method:

        raise Exception('please specify method name !')

    id_ = random.randrange(1, 9999)

    req = urllib2.Request('%s/_admin/api' % apihost,

                      data=json.dumps(_build_data(id_)),

                      headers={'content-type': 'text/plain'})

    if format == FORMAT_PRETTY:

        sys.stdout.write('calling %s to %s \n' % (req.get_data(), apihost))

    ret = urllib2.urlopen(req)

    raw_json = ret.read()

    json_data = json.loads(raw_json)

    id_ret = json_data['id']

    _formatted_json = pprint.pformat(json_data)

    if id_ret == id_:

        if format == FORMAT_JSON:

            sys.stdout.write(str(raw_json))

        else:

            sys.stdout.write('rhodecode returned:\n%s\n' % (_formatted_json))

    else:

        raise Exception('something went wrong. '

                        'ID mismatch got %s, expected %s | %s' % (

                                            id_ret, id_, _formatted_json))

def argparser(argv):

    parser = argparse.ArgumentParser(description='RhodeCode API cli',

                                     usage=usage)

    ## config

    group = parser.add_argument_group('config')

    group.add_argument('--apikey', help='api access key')

    group.add_argument('--apihost', help='api host')

    group = parser.add_argument_group('API')

    group.add_argument('method', metavar='METHOD', type=str,

            help='API method name to call followed by key:value attributes',

    )

    group.add_argument('--format', dest='format', type=str,

            help='output format default: `pretty` can '

                 'be also `%s`' % FORMAT_JSON,

            default=FORMAT_PRETTY

    )

    args, other = parser.parse_known_args()

    return parser, args, other

def main(argv=None):

    """

    Main execution function for cli

    :param argv:

    :type argv:

    """

    if argv is None:

        argv = sys.argv

    conf = None

    parser, args, other = argparser(argv)

    api_credentials_given = (args.apikey and args.apihost)

    if args.method == '_create_config':

        if not api_credentials_given:

            raise parser.error('_create_config requires --apikey and --apihost')

                                               'apihost': args.apihost})

    if not conf:

        if not conf:

            if not api_credentials_given:

                parser.error('Could not find config file and missing '

                             '--apikey or --apihost in params')

    apikey = args.apikey or conf['apikey']

    host = args.apihost or conf['apihost']

    method = args.method

    if method == '_create_config':

        sys.exit()

    try:

        margs = dict(map(lambda s: s.split(':', 1), other))

    except:

        sys.stderr.write('Error parsing arguments \n')

        sys.exit()

    api_call(apikey, host, args.format, method, **margs)

    return 0

if __name__ == '__main__':

    sys.exit(main(sys.argv))