# 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/>.

import logging

import datetime

import re

from pylons.i18n.translation import _

from rhodecode.model.meta import Session

from rhodecode.lib import helpers as h, unionrepo

from rhodecode.model import BaseModel

from rhodecode.model.db import PullRequest, PullRequestReviewers, Notification,\

    ChangesetStatus

from rhodecode.model.notification import NotificationModel

from rhodecode.lib.utils2 import safe_unicode

from rhodecode.lib.vcs.utils.hgcompat import scmutil

from rhodecode.lib.vcs.utils import safe_str

log = logging.getLogger(__name__)

class PullRequestModel(BaseModel):

    cls = PullRequest

    def __get_pull_request(self, pull_request):

        return self._get_instance(PullRequest, pull_request)

    def get_all(self, repo):

        repo = self._get_repo(repo)

        return PullRequest.query()\

                .filter(PullRequest.other_repo == repo)\

                .order_by(PullRequest.created_on.desc())\

                .all()

    def create(self, created_by, org_repo, org_ref, other_repo, other_ref,

               revisions, reviewers, title, description=None):

        from rhodecode.model.changeset_status import ChangesetStatusModel

        created_by_user = self._get_user(created_by)

        org_repo = self._get_repo(org_repo)

        """

        Returns a list of changesets that can be merged from org_repo@org_ref

        to other_repo@other_ref ... and the ancestor that would be used for merge

        :param org_repo:

        :param org_ref:

        :param other_repo:

        :param other_ref:

        :param tmp:

        """

        ancestor = None

        if alias == 'hg':

            # lookup up the exact node id

            _revset_predicates = {

                    'branch': 'branch',

                    'book': 'bookmark',

                    'tag': 'tag',

                    'rev': 'id',

                }

            org_rev_spec = "%s('%s')" % (_revset_predicates[org_ref[0]],

                                         safe_str(org_ref[1]))

                org_rev = org_repo._repo[scmutil.revrange(org_repo._repo,

                                                          [org_rev_spec])[-1]]

            other_rev_spec = "%s('%s')" % (_revset_predicates[other_ref[0]],

                                           safe_str(other_ref[1]))

                other_rev = other_repo._repo[scmutil.revrange(other_repo._repo,

                                                        [other_rev_spec])[-1]]

            #case two independent repos

            if org_repo != other_repo:

                hgrepo = unionrepo.unionrepository(other_repo.baseui,

                                                   other_repo.path,

                                                   org_repo.path)

                # all the changesets we are looking for will be in other_repo,

                # so rev numbers from hgrepo can be used in other_repo

            #no remote compare do it on the same repository

            else:

                hgrepo = other_repo._repo

            if merge:

                revs = ["ancestors(id('%s')) and not ancestors(id('%s')) and not id('%s')" %

                        (other_rev, org_rev, org_rev)]

                ancestors = scmutil.revrange(hgrepo,

                     ["ancestor(id('%s'), id('%s'))" % (org_rev, other_rev)])

                if len(ancestors) == 1:

                    ancestor = hgrepo[ancestors[0]].hex()

            else: