# -*- coding: utf-8 -*-

"""

    rhodecode.bin.gist

    ~~~~~~~~~~~~~~~~~~

    Gist CLI client for RhodeCode

    :created_on: May 9, 2013

    :author: marcink

    :copyright: (C) 2010-2013 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 stat

import argparse

import fileinput

from rhodecode.bin.base import json, api_call, RcConf, FORMAT_JSON, FORMAT_PRETTY

def argparser(argv):

    usage = (

      "rhodecode-gist [-h] [--format=FORMAT] [--apikey=APIKEY] [--apihost=APIHOST] "

      "[--config=CONFIG] [--save-config] [GIST OPTIONS] "

      "[filename or stdin use - for terminal stdin ]\n"

      "Create config file: rhodecode-gist --apikey=<key> --apihost=http://rhodecode.server --save-config"

    )

    parser = argparse.ArgumentParser(description='RhodeCode Gist 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.add_argument('--config', help='config file path DEFAULT: ~/.rhodecode')

    group.add_argument('--save-config', action='store_true',

                       help='save the given config into a file')

    group = parser.add_argument_group('GIST')

    group.add_argument('-p', '--private', action='store_true',

                       help='create private Gist')

    group.add_argument('-f', '--filename',

                       help='set uploaded gist filename, '

                            'also defines syntax highlighting')

    group.add_argument('-d', '--description', help='Gist description')

    group.add_argument('-l', '--lifetime', metavar='MINUTES',

                       help='gist lifetime in minutes, -1 (DEFAULT) is forever')

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

                       help='output format DEFAULT: `%s` can '

                       'be also `%s`' % (FORMAT_PRETTY, FORMAT_JSON),

            default=FORMAT_PRETTY

    )

    args, other = parser.parse_known_args()

    return parser, args, other

def _run(argv):

    conf = None

    parser, args, other = argparser(argv)

    api_credentials_given = (args.apikey and args.apihost)

    if args.save_config:

        if not api_credentials_given:

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

        conf = RcConf(config_location=args.config,

                      autocreate=True, config={'apikey': args.apikey,

                                               'apihost': args.apihost})

        sys.exit()

    if not conf:

        conf = RcConf(config_location=args.config, autoload=True)

        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']

    DEFAULT_FILENAME = 'gistfile1.txt'

    if other:

        # skip multifiles for now

        filename = other[0]

        if filename == '-':

            filename = DEFAULT_FILENAME

            gist_content = ''

            for line in fileinput.input('-'):

                gist_content += line

        else:

            with open(filename, 'rb') as f:

                gist_content = f.read()

    else:

        filename = DEFAULT_FILENAME

        gist_content = None

        # little bit hacky but cross platform check where the

        # stdin comes from we skip the terminal case it can be handled by '-'

        mode = os.fstat(0).st_mode

        if stat.S_ISFIFO(mode):

            # "stdin is piped"

            gist_content = sys.stdin.read()

        elif stat.S_ISREG(mode):

            # "stdin is redirected"

            gist_content = sys.stdin.read()

        else:

            # "stdin is terminal"

            pass

    # make sure we don't upload binary stuff

    if gist_content and '\0' in gist_content:

        raise Exception('Error: binary files upload is not possible')

    filename = os.path.basename(args.filename or filename)

    if gist_content:

        files = {

            filename: {

                'content': gist_content,

                'lexer': None

            }

        }

        margs = dict(

            gist_type='private' if args.private else 'public',

            files=files

        )

        json_data = api_call(apikey, host, 'create_gist', **margs)['result']

        if args.format == FORMAT_JSON:

            print json.dumps(json_data)

        elif args.format == FORMAT_PRETTY:

    return 0

def main(argv=None):

    """

    Main execution function for cli

    :param argv:

    """

    if argv is None:

        argv = sys.argv

    try:

        return _run(argv)

    except Exception, e:

        print e

        return 1

if __name__ == '__main__':

    sys.exit(main(sys.argv))

        for users_group in repo.users_group_to_perm:

            perm = users_group.permission.permission_name

            users_group = users_group.users_group

            users_group_data = users_group.get_api_data()

            users_group_data['type'] = "users_group"

            users_group_data['permission'] = perm

            members.append(users_group_data)

        for user in repo.followers:

            followers.append(user.user.get_api_data())

        data = repo.get_api_data()

        data['members'] = members

        data['followers'] = followers

        return data

    # permission check inside

    def get_repos(self, apiuser):

        """"

        Get all repositories

        :param apiuser:

        """

        result = []

        if HasPermissionAnyApi('hg.admin')(user=apiuser) is False:

            repos = RepoModel().get_all_user_repos(user=apiuser)

        else:

            repos = RepoModel().get_all()

        for repo in repos:

            result.append(repo.get_api_data())

        return result

    @HasPermissionAllDecorator('hg.admin')

    def get_repo_nodes(self, apiuser, repoid, revision, root_path,

                       ret_type='all'):

        """

        returns a list of nodes and it's children

        for a given path at given revision. It's possible to specify ret_type

        to show only files or dirs

        :param apiuser:

        :param repoid: name or id of repository

        :param revision: revision for which listing should be done

        :param root_path: path from which start displaying

        :param ret_type: return type 'all|files|dirs' nodes

        """

        repo = get_repo_or_error(repoid)

        try:

            _d, _f = ScmModel().get_nodes(repo, revision, root_path,

                                          flat=False)

            _map = {

                'all': _d + _f,

                'files': _f,

                'dirs': _d,

            }

            return _map[ret_type]

        except KeyError:

            raise JSONRPCError('ret_type must be one of %s' % _map.keys())

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to get repo: `%s` nodes' % repo.repo_name

            )

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create_repo(self, apiuser, repo_name, owner=Optional(OAttr('apiuser')),

                    repo_type=Optional('hg'),

                    description=Optional(''), private=Optional(False),

                    clone_uri=Optional(None), landing_rev=Optional('tip'),

                    enable_statistics=Optional(False),

                    enable_locking=Optional(False),

                    enable_downloads=Optional(False)):

        """

        Create repository, if clone_url is given it makes a remote clone

        if repo_name is within a group name the groups will be created

        automatically if they aren't present

        :param apiuser:

        :param repo_name:

        :param onwer:

        :param repo_type:

        :param description:

        :param private:

        :param clone_uri:

        :param landing_rev:

        """

        if HasPermissionAnyApi('hg.admin')(user=apiuser) is False:

            if not isinstance(owner, Optional):

                #forbid setting owner for non-admins

                raise JSONRPCError(

                    'Only RhodeCode admin can specify `owner` param'

                )

        if isinstance(owner, Optional):

            owner = apiuser.user_id

        owner = get_user_or_error(owner)

        if RepoModel().get_by_repo_name(repo_name):

            raise JSONRPCError("repo `%s` already exist" % repo_name)

        defs = RhodeCodeSetting.get_default_repo_settings(strip_prefix=True)

        if isinstance(private, Optional):

            private = defs.get('repo_private') or Optional.extract(private)

        if isinstance(repo_type, Optional):

            repo_type = defs.get('repo_type')

        if isinstance(enable_statistics, Optional):

            enable_statistics = defs.get('repo_enable_statistics')

        if isinstance(enable_locking, Optional):

            enable_locking = defs.get('repo_enable_locking')

        if isinstance(enable_downloads, Optional):

            enable_downloads = defs.get('repo_enable_downloads')

        clone_uri = Optional.extract(clone_uri)

        description = Optional.extract(description)

        landing_rev = Optional.extract(landing_rev)

        try:

            # create structure of groups and return the last group

            group = map_groups(repo_name)

            repo = RepoModel().create_repo(

                repo_name=repo_name,

                repo_type=repo_type,

                description=description,

                owner=owner,

                private=private,

                clone_uri=clone_uri,

                repos_group=group,

                landing_rev=landing_rev,

                enable_statistics=enable_statistics,

                enable_downloads=enable_downloads,

                enable_locking=enable_locking

            )

            Session().commit()

            return dict(

                msg="Created new repository `%s`" % (repo.repo_name),

                repo=repo.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create repository `%s`' % repo_name)

    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')

    def fork_repo(self, apiuser, repoid, fork_name, owner=Optional(OAttr('apiuser')),

                  description=Optional(''), copy_permissions=Optional(False),

                  private=Optional(False), landing_rev=Optional('tip')):

        repo = get_repo_or_error(repoid)

        repo_name = repo.repo_name

        _repo = RepoModel().get_by_repo_name(fork_name)

        if _repo:

            type_ = 'fork' if _repo.fork else 'repo'

            raise JSONRPCError("%s `%s` already exist" % (type_, fork_name))

        if HasPermissionAnyApi('hg.admin')(user=apiuser):

            pass

        elif HasRepoPermissionAnyApi('repository.admin',

                                     'repository.write',

                                     'repository.read')(user=apiuser,

                                                        repo_name=repo.repo_name):

            if not isinstance(owner, Optional):

                #forbid setting owner for non-admins

                raise JSONRPCError(

                    'Only RhodeCode admin can specify `owner` param'

                )

        else:

            raise JSONRPCError('repository `%s` does not exist' % (repoid))

        if isinstance(owner, Optional):

            owner = apiuser.user_id

        owner = get_user_or_error(owner)

        try:

            # create structure of groups and return the last group

            group = map_groups(fork_name)

            form_data = dict(

                repo_name=fork_name,

                repo_name_full=fork_name,

                repo_group=group,

                repo_type=repo.repo_type,

                description=Optional.extract(description),

                private=Optional.extract(private),

                copy_permissions=Optional.extract(copy_permissions),

                landing_rev=Optional.extract(landing_rev),

                update_after_clone=False,

                fork_parent_id=repo.repo_id,

            )

            RepoModel().create_fork(form_data, cur_user=owner)

            return dict(

                msg='Created fork of `%s` as `%s`' % (repo.repo_name,

                                                      fork_name),

                success=True  # cannot return the repo data here since fork

                              # cann be done async

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to fork repository `%s` as `%s`' % (repo_name,

                                                            fork_name)

            )

    # perms handled inside

    def delete_repo(self, apiuser, repoid, forks=Optional(None)):

        """

        Deletes a given repository

        :param apiuser:

        :param repoid:

        :param forks: detach or delete, what do do with attached forks for repo

        """

        repo = get_repo_or_error(repoid)

        if HasPermissionAnyApi('hg.admin')(user=apiuser) is False:

            # check if we have admin permission for this repo !

            if HasRepoPermissionAnyApi('repository.admin')(user=apiuser,

                                            repo_name=repo.repo_name) is False:

                raise JSONRPCError('repository `%s` does not exist' % (repoid))

        try:

            handle_forks = Optional.extract(forks)

            _forks_msg = ''

            _forks = [f for f in repo.forks]

            if handle_forks == 'detach':

                _forks_msg = ' ' + 'Detached %s forks' % len(_forks)

            elif handle_forks == 'delete':

                _forks_msg = ' ' + 'Deleted %s forks' % len(_forks)

            elif _forks:

                raise JSONRPCError(

                    'Cannot delete `%s` it still contains attached forks'

                    % repo.repo_name

                )

            RepoModel().delete(repo, forks=forks)

            Session().commit()

            return dict(

                msg='Deleted repository `%s`%s' % (repo.repo_name, _forks_msg),

                success=True

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to delete repository `%s`' % repo.repo_name

            )

    @HasPermissionAllDecorator('hg.admin')

    def grant_user_permission(self, apiuser, repoid, userid, perm):

        """

        Grant permission for user on given repository, or update existing one

        if found

        :param repoid:

        :param userid:

        :param perm:

        """

        repo = get_repo_or_error(repoid)

        user = get_user_or_error(userid)

        perm = get_perm_or_error(perm)

        try:

            RepoModel().grant_user_permission(repo=repo, user=user, perm=perm)

            Session().commit()

            return dict(

                msg='Granted perm: `%s` for user: `%s` in repo: `%s`' % (

                    perm.permission_name, user.username, repo.repo_name

                ),

                success=True

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to edit permission for user: `%s` in repo: `%s`' % (

                    userid, repoid

                )

            )

    @HasPermissionAllDecorator('hg.admin')

    def revoke_user_permission(self, apiuser, repoid, userid):

        """

        Revoke permission for user on given repository

        :param apiuser:

        :param repoid:

        :param userid:

        """

        repo = get_repo_or_error(repoid)

        user = get_user_or_error(userid)

        try:

            RepoModel().revoke_user_permission(repo=repo, user=user)

            Session().commit()

            return dict(

                msg='Revoked perm for user: `%s` in repo: `%s`' % (

                    user.username, repo.repo_name

                ),

                success=True

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to edit permission for user: `%s` in repo: `%s`' % (

                    userid, repoid

                )

            )

    @HasPermissionAllDecorator('hg.admin')

    def grant_users_group_permission(self, apiuser, repoid, usersgroupid,

                                     perm):

        """

        Grant permission for user group on given repository, or update

        existing one if found

        :param apiuser:

        :param repoid:

        :param usersgroupid:

        :param perm:

        """

        repo = get_repo_or_error(repoid)

        perm = get_perm_or_error(perm)

        users_group = get_users_group_or_error(usersgroupid)

        try:

            RepoModel().grant_users_group_permission(repo=repo,

                                                     group_name=users_group,

                                                     perm=perm)

            Session().commit()

            return dict(

                msg='Granted perm: `%s` for user group: `%s` in '

                    'repo: `%s`' % (

                    perm.permission_name, users_group.users_group_name,

                    repo.repo_name

                ),

                success=True

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to edit permission for user group: `%s` in '

                'repo: `%s`' % (

                    usersgroupid, repo.repo_name

                )

            )

    @HasPermissionAllDecorator('hg.admin')

    def revoke_users_group_permission(self, apiuser, repoid, usersgroupid):

        """

        Revoke permission for user group on given repository

        :param apiuser:

        :param repoid:

        :param usersgroupid:

        """

        repo = get_repo_or_error(repoid)

        users_group = get_users_group_or_error(usersgroupid)

        try:

            RepoModel().revoke_users_group_permission(repo=repo,

                                                      group_name=users_group)

            Session().commit()

            return dict(

                msg='Revoked perm for user group: `%s` in repo: `%s`' % (

                    users_group.users_group_name, repo.repo_name

                ),

                success=True

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to edit permission for user group: `%s` in '

                'repo: `%s`' % (

                    users_group.users_group_name, repo.repo_name

                )

            )

    def create_gist(self, apiuser, files, owner=Optional(OAttr('apiuser')),

        try:

            if isinstance(owner, Optional):

                owner = apiuser.user_id

            owner = get_user_or_error(owner)

            gist_type = Optional.extract(gist_type)

            # files: {

            #    'filename': {'content':'...', 'lexer': null},

            #    'filename2': {'content':'...', 'lexer': null}

            #}

            gist = GistModel().create(description=description,

                                      owner=owner,

                                      gist_mapping=files,

                                      gist_type=gist_type,

            Session().commit()

            return dict(

                msg='created new gist',

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create gist')