# Copyright (C) 2011 Canonical Ltd
#
# 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 2 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA


from bzrlib import (
    branch,
    urlutils,
    )
from bzrlib.tests import (
    script,
    )


class TestRememberMixin(object):
    """--remember and --no-remember set locations or not."""

    # the command to run (expecting additional arguments from the tests
    command = []
    # the dir where the command should be run (it should contain a branch for
    # which the tested locations are/will be set)
    working_dir = None
    # argument list for the first command invocation
    first_use_args = []
    # argument list for the next command invocation
    next_uses_args = []

    def do_command(self, *args):
        # We always expect the same result here and care only about the
        # arguments used and their consequences on the remembered locations
        out, err = self.run_bzr(self.command + list(args),
                                working_dir=self.working_dir)

    def test_first_use_no_option(self):
        self.do_command(*self.first_use_args)
        self.assertLocations(self.first_use_args)

    def test_first_use_remember(self):
        self.do_command('--remember', *self.first_use_args)
        self.assertLocations(self.first_use_args)

    def test_first_use_no_remember(self):
        self.do_command('--no-remember', *self.first_use_args)
        self.assertLocations([])

    def test_next_uses_no_option(self):
        self.setup_next_uses()
        self.do_command(*self.next_uses_args)
        self.assertLocations(self.first_use_args)

    def test_next_uses_remember(self):
        self.setup_next_uses()
        self.do_command('--remember', *self.next_uses_args)
        self.assertLocations(self.next_uses_args)

    def test_next_uses_no_remember(self):
        self.setup_next_uses()
        self.do_command('--no-remember', *self.next_uses_args)
        self.assertLocations(self.first_use_args)


class TestSendRemember(script.TestCaseWithTransportAndScript,
                       TestRememberMixin):

    working_dir = 'work'
    command = ['send', '-o-',]
    first_use_args = ['../parent', '../grand_parent',]
    next_uses_args = ['../new_parent', '../new_grand_parent']

    def setUp(self):
        super(TestSendRemember, self).setUp()
        self.run_script('''
            $ bzr init grand_parent
            $ cd grand_parent
            $ echo grand_parent > file
            $ bzr add
            $ bzr commit -m 'initial commit'
            $ cd ..
            $ bzr branch grand_parent parent
            $ cd parent
            $ echo parent > file
            $ bzr commit -m 'parent'
            $ cd ..
            $ bzr branch parent %(working_dir)s
            $ cd %(working_dir)s
            $ echo %(working_dir)s > file
            $ bzr commit -m '%(working_dir)s'
            $ cd ..
            ''' % {'working_dir': self.working_dir},
                        null_output_matches_anything=True)

    def setup_next_uses(self):
        # Do a first send that remembers the locations
        self.do_command(*self.first_use_args)
        # Now create some new targets
        self.run_script('''
            $ bzr branch grand_parent new_grand_parent
            $ bzr branch parent new_parent
            ''',
                        null_output_matches_anything=True)

    def assertLocations(self, expected_locations):
        if not expected_locations:
            expected_submit_branch, expected_public_branch = None, None
        else:
            expected_submit_branch, expected_public_branch = expected_locations
        br, _ = branch.Branch.open_containing(self.working_dir)
        self.assertEquals(expected_submit_branch, br.get_submit_branch())
        self.assertEquals(expected_public_branch, br.get_public_branch())


class TestPushRemember(script.TestCaseWithTransportAndScript,
                       TestRememberMixin):

    working_dir = 'work'
    command = ['push',]
    first_use_args = ['../target',]
    next_uses_args = ['../new_target']

    def setUp(self):
        super(TestPushRemember, self).setUp()
        self.run_script('''
            $ bzr init %(working_dir)s
            $ cd %(working_dir)s
            $ echo some content > file
            $ bzr add
            $ bzr commit -m 'initial commit'
            $ cd ..
            ''' % {'working_dir': self.working_dir},
                        null_output_matches_anything=True)

    def setup_next_uses(self):
        # Do a first push that remembers the location
        self.do_command(*self.first_use_args)
        # Now create some new content
        self.run_script('''
            $ cd %(working_dir)s
            $ echo new content > file
            $ bzr commit -m 'new content'
            $ cd ..
            ''' % {'working_dir': self.working_dir},
                        null_output_matches_anything=True)

    def assertLocations(self, expected_locations):
        br, _ = branch.Branch.open_containing(self.working_dir)
        if not expected_locations:
            self.assertEquals(None, br.get_push_location())
        else:
            expected_push_location = expected_locations[0]
            push_location = urlutils.relative_url(br.base,
                                                  br.get_push_location())
            self.assertIsSameRealPath(expected_push_location, push_location)


class TestPullRemember(script.TestCaseWithTransportAndScript,
                       TestRememberMixin):

    working_dir = 'work'
    command = ['pull',]
    first_use_args = ['../parent',]
    next_uses_args = ['../new_parent']

    def setUp(self):
        super(TestPullRemember, self).setUp()
        self.run_script('''
            $ bzr init parent
            $ cd parent
            $ echo parent > file
            $ bzr add
            $ bzr commit -m 'initial commit'
            $ cd ..
            $ bzr init %(working_dir)s
            ''' % {'working_dir': self.working_dir},
                        null_output_matches_anything=True)

    def setup_next_uses(self):
        # Do a first push that remembers the location
        self.do_command(*self.first_use_args)
        # Now create some new content
        self.run_script('''
            $ bzr branch parent new_parent
            $ cd new_parent
            $ echo new parent > file
            $ bzr commit -m 'new parent'
            $ cd ..
            ''' % {'working_dir': self.working_dir},
                        null_output_matches_anything=True)

    def assertLocations(self, expected_locations):
        br, _ = branch.Branch.open_containing(self.working_dir)
        if not expected_locations:
            self.assertEquals(None, br.get_parent())
        else:
            expected_pull_location = expected_locations[0]
            pull_location = urlutils.relative_url(br.base, br.get_parent())
            self.assertIsSameRealPath(expected_pull_location, pull_location)
