# This file is part of txgithub.  txgithub 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, version 2.
#
# 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, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members

import re
import json
from twisted.python import log
from twisted.internet import defer, ssl
from twisted.web import client

class _GithubPageGetter(client.HTTPPageGetter):

    def handleStatus_204(self):
        # github returns 204 for e.g., DELETE operations
        self.handleStatus_200()

class _GithubHTTPClientFactory(client.HTTPClientFactory):

    protocol = _GithubPageGetter

    # dont' log about starting and stopping
    noisy = False

class GithubApi(object):
    # Interface to the github API, using
    # - API v3
    # - optional user/pass auth (token is not available with v3)
    # - async API

    def __init__(self, oauth2_token, baseURL=None, reactor=None):
        self._baseURL = baseURL or 'https://api.github.com/'
        self.oauth2_token = oauth2_token
        self.rateLimitWarningIssued = False
        self.contextFactory = ssl.ClientContextFactory()
        if reactor is None:
            from twisted.internet import reactor
        self.reactor = reactor

    def _makeHeaders(self):
        assert self.oauth2_token, "no token specified"
        return { 'Authorization' : 'token ' + self.oauth2_token }

    def makeRequest(self, url_args, post=None, method='GET', page=0):
        headers = self._makeHeaders()

        url = self._baseURL
        url += '/'.join(url_args)
        if page:
            url += "?page=%d" % page

        postdata = None
        if post:
            postdata = json.dumps(post)

        log.msg("fetching '%s'" % (url,), system='github')
        factory = _GithubHTTPClientFactory(url, headers=headers,
                    postdata=postdata, method=method,
                    agent='txgithub', followRedirect=0,
                    timeout=30)

        self.reactor.connectSSL(factory.host, factory.port, factory,
                                self.contextFactory)
        d = factory.deferred
        @d.addCallback
        def check_ratelimit(data):
            self.last_response_headers = factory.response_headers
            remaining = int(factory.response_headers.get(
                                    'x-ratelimit-remaining', [0])[0])
            if remaining < 100 and not self.rateLimitWarningIssued:
                log.msg("warning: only %d Github API requests remaining "
                        "before rate-limiting" % remaining)
                self.rateLimitWarningIssued = True
            return data
        @d.addCallback
        def un_json(data):
            if data:
                return json.loads(data)
        return d

    link_re = re.compile('<([^>]*)>; rel="([^"]*)"')
    @defer.inlineCallbacks
    def makeRequestAllPages(self, url_args):
        page = 0
        data = []
        while True:
            data.extend((yield self.makeRequest(url_args, page=page)))
            if 'link' not in self.last_response_headers:
                break
            link_hdr = self.last_response_headers['link'][0]
            for link in self.link_re.findall(link_hdr):
                if link[1] == 'next':
                    # note that we don't *use* the page -- why bother?
                    break
            else:
                break # no 'next' link, so we're done
            page += 1
        defer.returnValue(data)

    _repos = None
    @property
    def repos(self):
        if not self._repos:
            self._repos = ReposEndpoint(self)
        return self._repos

    _gists = None
    @property
    def gists(self):
        if not self._gists:
            self._gists = GistsEndpoint(self)
        return self._gists

    _pulls = None
    @property
    def pulls(self):
        if not self._pulls:
            self._pulls = PullsEndpoint(self)
        return self._pulls

    _comments = None
    @property
    def comments(self):
        if not self._comments:
            self._comments = IssueCommentsEndpoint(self)
        return self._comments

    _reviews = None
    @property
    def reviews(self):
        if not self._reviews:
            self._reviews = ReviewCommentsEndpoint(self)
        return self._reviews


class BaseEndpoint(object):

    def __init__(self, api):
        self.api = api


class ReposEndpoint(BaseEndpoint):

    @defer.inlineCallbacks
    def getEvents(self, repo_user, repo_name, until_id=None):
        """Get all repository events, following paging, until the end
        or until UNTIL_ID is seen.  Returns a Deferred."""
        done = False
        page = 0
        events = []
        while not done:
            new_events = yield self.api.makeRequest(
                    ['repos', repo_user, repo_name, 'events'],
                    page)

            # terminate if we find a matching ID
            if new_events:
                for event in new_events:
                    if event['id'] == until_id:
                        done = True
                        break
                    events.append(event)
            else:
                done = True

            page += 1
        defer.returnValue(events)

    def getHooks(self, repo_user, repo_name):
        """Get all repository hooks.  Returns a Deferred."""
        return self.api.makeRequestAllPages(
            ['repos', repo_user, repo_name, 'hooks'])

    def getHook(self, repo_user, repo_name, hook_id):
        """
        GET /repos/:owner/:repo/hooks/:id

        Returns the Hook.
        """
        return self.api.makeRequest(
            ['repos', repo_user, repo_name, 'hooks', str(hook_id)],
            method='GET',
            )

    def createHook(self, repo_user, repo_name, name, config, events, active):
        return self.api.makeRequest(
            ['repos', repo_user, repo_name, 'hooks'],
            method='POST',
            post=dict(name=name, config=config, events=events, active=active))

    def editHook(self, repo_user, repo_name, hook_id, name, config,
            events=None, add_events=None, remove_events=None, active=None):
        """
        PATCH /repos/:owner/:repo/hooks/:id

        :param hook_id: Id of the hook.
        :param name:  The name of the service that is being called.
        :param config: A Hash containing key/value pairs to provide settings
                       for this hook.
        """
        post = dict(
                name=name,
                config=config,
                )
        if events is not None:
            post['events'] = events

        if add_events is not None:
            post['add_events'] = add_events

        if remove_events is not None:
            post['remove_events'] = remove_events

        if active is not None:
            post['active'] = active

        return self.api.makeRequest(
            ['repos', repo_user, repo_name, 'hooks', str(hook_id)],
            method='PATCH',
            post=post,
            )

    def testHook(self, repo_user, repo_name, hook_id):
        """
        POST /repos/:owner/:repo/hooks/:id/tests

        Response headers:
            Status: 204 No Content
            X-RateLimit-Limit: 5000
            X-RateLimit-Remaining: 4999
        Response content:
            None
        """
        return self.api.makeRequest(
            ['repos', repo_user, repo_name, 'hooks', str(hook_id), 'tests'],
            method='POST',
            )

    def deleteHook(self, repo_user, repo_name, id):
        return self.api.makeRequest(
            ['repos', repo_user, repo_name, 'hooks', str(id)],
            method='DELETE')

    def getStatuses(self, repo_user, repo_name, sha):
        """
        :param sha: Full sha to list the statuses from.
        :return: A defered with the result from GitHub.
        """
        return self.api.makeRequest(
            ['repos', repo_user, repo_name, 'statuses', sha],
            method='GET')

    def createStatus(self,
            repo_user, repo_name, sha, state, target_url=None,
            description=None, context=None):
        """
        :param sha: Full sha to create the status for.
        :param state: one of the following 'pending', 'success', 'error'
                      or 'failure'.
        :param target_url: Target url to associate with this status.
        :param description: Short description of the status.
        :return: A defered with the result from GitHub.
        """
        payload = {'state': state}

        if description is not None:
            payload['description'] = description

        if target_url is not None:
            payload['target_url'] = target_url

        if context is not None:
            payload['context'] = context

        return self.api.makeRequest(
            ['repos', repo_user, repo_name, 'statuses', sha],
            method='POST',
            post=payload)


class GistsEndpoint(BaseEndpoint):
    def create(self, files, description=None, public=True):
        data = { 'files': files, 'public': bool(public) }
        if description is not None:
            data['description'] = description
        return self.api.makeRequest(
                ['gists'],
                method='POST',
                post=data)


class PullsEndpoint(BaseEndpoint):
    def edit(self, repo_user, repo_name, pull_number,
             title=None, body=None, state=None):
        """
        PATCH /repos/:owner/:repo/pulls/:number

        :param pull_number: The pull request's number
        :param title: The new title for the pull request
        :param body: The new top-level body for the pull request
        :param state: The new top-level body for the pull request
        """
        if not any((title, body, state)):
            raise ValueError("must provide at least one of:"
                             " title, body, state")

        post = {}
        if title is not None:
            post['title'] = title
        if body is not None:
            post['body'] = body
        if state is not None:
            if state not in ('open', 'closed'):
                raise ValueError("state must be either 'open' or 'closed'")
            post['state'] = state

        return self.api.makeRequest(
            ['repos', repo_user, repo_name, 'pulls', pull_number],
            method='PATCH',
            post=post)


class IssueCommentsEndpoint(BaseEndpoint):
    def create(self, repo_user, repo_name, issue_number, body):
        """
        PATCH /repos/:owner/:repo/issues/:number/comments

        :param issue_number: The issue's (or pull request's) number
        :param body: The body of this comment
        """
        return self.api.makeRequest(
            ['repos', repo_user, repo_name,
             'issues', issue_number, 'comments'],
            method='POST',
            post=dict(body=body))


class ReviewCommentsEndpoint(BaseEndpoint):
    def getRepoComments(self, repo_user, repo_name):
        """
        GET /repos/:owner/:repo/pulls/comments
        """
        return self.api.makeRequestAllPages(
            ['repos', repo_user, repo_name, 'pulls', 'comments'])

    def getPullRequestComments(self, repo_user, repo_name, pull_number):
        """
        GET /repos/:owner/:repo/pulls/:number/comments

        :param pull_number: The pull request's number.
        """
        return self.api.makeRequestAllPages(
            ['repos', repo_user, repo_name,
             'pulls', str(pull_number), 'comments'])

    def getComment(self, repo_user, repo_name, comment_id):
        """
        GET /repos/:owner/:repo/pull/comments/:number

        :param comment_id: The review comment's ID.
        """
        return self.api.makeRequest(
            ['repos', repo_user, repo_name,
             'pulls', 'comments', str(comment_id)])

    def createComment(self, repo_user, repo_name, pull_number,
                      body, commit_id, path, position):
        """
        POST /repos/:owner/:repo/pulls/:number/comments

        :param pull_number: The pull request's ID.
        :param body: The text of the comment.
        :param commit_id: The SHA of the commit to comment on.
        :param path: The relative path of the file to comment on.
        :param position: The line index in the diff to comment on.
        """
        return self.api.makeRequest(
            ["repos", repo_user, repo_name,
             "pulls", str(pull_number), "comments"],
            method="POST",
            data=dict(body=body,
                      commit_id=commit_id,
                      path=path,
                      position=position))

    def replyToComment(self, repo_user, repo_name, pull_number,
                       body, in_reply_to):
        """
        POST /repos/:owner/:repo/pulls/:number/comments

        Like create, but reply to an existing comment.

        :param body: The text of the comment.
        :param in_reply_to: The comment ID to reply to.
        """
        return self.api.makeRequest(
            ["repos", repo_user, repo_name,
             "pulls", str(pull_number), "comments"],
            method="POST",
            data=dict(body=body,
                      in_reply_to=in_reply_to))

    def editComment(self, repo_user, repo_name, comment_id, body):
        """
        PATCH /repos/:owner/:repo/pulls/comments/:id

        :param comment_id: The ID of the comment to edit
        :param body: The new body of the comment.
        """
        return self.api.makeRequest(
            ["repos", repo_user, repo_name,
             "pulls", "comments", str(comment_id)],
            method="POST",
            data=dict(body=body))

    def deleteComment(self, repo_user, repo_name, comment_id):
        """
        DELETE /repos/:owner/:repo/pulls/comments/:id

        :param comment_id: The ID of the comment to edit
        :param body: The new body of the comment.
        """
        return self.api.makeRequest(
            ["repos", repo_user, repo_name,
             "pulls", "comments", str(comment_id)],
            method="DELETE")