#!/usr/bin/env python
"""\
This encapsulates the functionality for trying to rsync a local
working tree to/from a remote rsync accessible location.
"""

import os
import bzrlib

_rsync_location = 'x-rsync-data'
_parent_locations = ['parent', 'pull', 'x-pull']

def temp_branch():
    import tempfile
    dirname = tempfile.mkdtemp("temp-branch")
    return bzrlib.Branch(dirname, init=True)

def rm_branch(branch):
    import shutil
    shutil.rmtree(branch.base)

def is_clean(branch):
    """
    Return true if no files are modifed or unknown
    >>> br = temp_branch()
    >>> is_clean(br)
    True
    >>> fooname = os.path.join(br.base, "foo")
    >>> file(fooname, "wb").write("bar")
    >>> is_clean(br)
    False
    >>> bzrlib.add.smart_add([fooname])
    >>> is_clean(br)
    False
    >>> br.commit("added file")
    >>> is_clean(br)
    True
    >>> rm_branch(br)
    """
    old_tree = branch.basis_tree()
    new_tree = branch.working_tree()
    for path, file_class, kind, file_id in new_tree.list_files():
        if file_class == '?':
            return False
    delta = bzrlib.compare_trees(old_tree, new_tree, want_unchanged=False)
    if len(delta.added) > 0 or len(delta.removed) > 0 or \
        len(delta.modified) > 0:
        return False
    return True

def get_default_remote_info(branch):
    """Return the value stored in .bzr/x-rsync-location if it exists.
    
    >>> br = temp_branch()
    >>> get_default_remote_info(br)
    (None, 0, None)
    >>> import bzrlib.commit
    >>> bzrlib.commit.commit(br, 'test commit', rev_id='test-id-12345')
    >>> set_default_remote_info(br, 'http://somewhere')
    >>> get_default_remote_info(br)
    ('http://somewhere', 1, 'test-id-12345')
    """
    def_remote = None
    revno = 0
    revision = None
    def_remote_filename = branch.controlfilename(_rsync_location)
    if os.path.isfile(def_remote_filename):
        [def_remote,revno, revision] = [x.strip() for x in open(def_remote_filename).readlines()]
    return def_remote, int(revno), revision

def set_default_remote_info(branch, location):
    """Store the location into the .bzr/x-rsync-location.
    
    """
    from bzrlib.atomicfile import AtomicFile
    remote, revno, revision = get_default_remote_info(branch)
    if (remote == location 
        and revno == branch.revno()
        and revision == branch.last_patch()):
        return #Nothing would change, so skip it
    # TODO: Consider adding to x-pull so that we can try a RemoteBranch
    # for checking the need to update
    f = AtomicFile(branch.controlfilename(_rsync_location))
    f.write(location)
    f.write('\n')
    f.write(str(branch.revno()))
    f.write('\n')
    f.write(branch.last_patch())
    f.write('\n')
    f.commit()

def get_parent_branch(branch):
    """Try to get the pull location, in case this directory supports the normal bzr pull.
    
    The idea is that we can use RemoteBranch to see if we actually need to do anything,
    and then we can decide whether to run rsync or not.
    """
    import errno
    stored_loc = None
    for fname in _parent_locations:
        try:
            stored_loc = branch.controlfile(fname, 'rb').read().rstrip('\n')
        except IOError, e:
            if e.errno != errno.ENOENT:
                raise

        if stored_loc:
            break

    if stored_loc:
        from bzrlib.branch import find_branch
        return find_branch(stored_loc)
    return None

def get_branch_remote_update(local=None, remote=None, alt_remote=None):
    from bzrlib.errors import BzrCommandError
    from bzrlib.branch import find_branch
    if local is None:
        local = '.'

    if remote is not None and remote[-1:] != '/':
        remote += '/'

    if alt_remote is not None and alt_remote[-1:] != '/':
        alt_remote += '/'

    if not os.path.exists(local):
        if remote is None:
            remote = alt_remote
        if remote is None:
            raise BzrCommandError('No remote location specified while creating a new local location')
        return local, remote, 0, None

    b = find_branch(local)

    def_remote, last_revno, last_revision = get_default_remote_info(b)
    if remote is None:
        if def_remote is None:
            if alt_remote is None:
                raise BzrCommandError('No remote location specified, and no default exists.')
            else:
                remote = alt_remote
        else:
            remote = def_remote

    if remote[-1:] != '/':
        remote += '/'

    return b, remote, last_revno, last_revision

def check_should_pull(branch, last_revno, last_revision):
    if isinstance(branch, basestring): # We don't even have a local branch yet
        return True

    if not is_clean(branch):
        print '** Local tree is not clean. Either has unknown or modified files.'
        return False

    b_parent = get_parent_branch(branch)
    if b_parent is not None:
        from bzrlib.branch import DivergedBranches
        # This may throw a Diverged branches.
        try:
            missing_revisions = branch.missing_revisions(b_parent)
        except DivergedBranches:
            print '** Local tree history has diverged from remote.'
            print '** Not allowing you to overwrite local changes.'
            return False
        if len(missing_revisions) == 0:
            # There is nothing to do, the remote branch has no changes
            missing_revisions = b_parent.missing_revisions(branch)
            if len(missing_revisions) > 0:
                print '** Local tree is up-to-date with remote.'
                print '** But remote tree is missing local revisions.'
                print '** Consider using bzr rsync-push'
            else:
                print '** Both trees fully up-to-date.'
            return False
        # We are sure that we are missing remote revisions
        return True

    if last_revno == branch.revno() and last_revision == branch.last_patch():
        # We can go ahead and try
        return True

    print 'Local working directory has a different revision than last rsync.'
    val = raw_input('Are you sure you want to download [y/N]? ')
    if val.lower() in ('y', 'yes'):
        return True
    return False

def check_should_push(branch, last_revno, last_revision):
    if not is_clean(branch):
        print '** Local tree is not clean (either modified or unknown files)'
        return False

    b_parent = get_parent_branch(branch)
    if b_parent is not None:
        from bzrlib.branch import DivergedBranches
        # This may throw a Diverged branches.
        try:
            missing_revisions = b_parent.missing_revisions(branch)
        except DivergedBranches:
            print '** Local tree history has diverged from remote.'
            print '** Not allowing you to overwrite remote changes.'
            return False
        if len(missing_revisions) == 0:
            # There is nothing to do, the remote branch is up to date
            missing_revisions = branch.missing_revisions(b_parent)
            if len(missing_revisions) > 0:
                print '** Remote tree is up-to-date with local.'
                print '** But local tree is missing remote revisions.'
                print '** Consider using bzr rsync-pull'
            else:
                print '** Both trees fully up-to-date.'
            return False
        # We are sure that we are missing remote revisions
        return True

    if last_revno is None and last_revision is None:
        print 'Local tree does not have a valid last rsync revision.'
        val = raw_input('push anyway [y/N]? ')
        if val.lower() in ('y', 'yes'):
            return True
        return False

    if last_revno == branch.revno() and last_revision == branch.last_patch():
        print 'No new revisions.'
        return False

    return True


def pull(branch, remote, verbose=False, dry_run=False):
    """Update the local repository from the location specified by 'remote'

    :param branch:  Either a string specifying a local path, or a Branch object.
                    If a local path, the download will be performed, and then
                    a Branch object will be created.

    :return:    Return the branch object that was created
    """
    if isinstance(branch, basestring):
        local = branch
        cur_revno = 0
    else:
        local = branch.base
        cur_revno = branch.revno()
    if remote[-1:] != '/':
        remote += '/'

    rsyncopts = ['-rltp', '--delete'
        # Don't pull in a new parent location
        , "--exclude '**/.bzr/x-rsync*'", "--exclude '**/.bzr/x-pull*'" 
        , "--exclude '**/.bzr/parent'", "--exclude '**/.bzr/pull'"
        ]

    # Note that when pulling, we do not delete excluded files
    rsync_exclude = os.path.join(local, '.rsyncexclude')
    if os.path.exists(rsync_exclude):
        rsyncopts.append('--exclude-from "%s"' % rsync_exclude)
    bzr_ignore = os.path.join(local, '.bzrignore')
    if os.path.exists(bzr_ignore):
        rsyncopts.append('--exclude-from "%s"' % bzr_ignore)

    if verbose:
        rsyncopts.append('-v')
    if dry_run:
        rsyncopts.append('--dry-run')

    cmd = 'rsync %s "%s" "%s"' % (' '.join(rsyncopts), remote, local)
    if verbose:
        print cmd

    status = os.system(cmd)
    if status != 0:
        from bzrlib.errors import BzrError
        raise BzrError('Rsync failed with error code: %s' % status)


    if isinstance(branch, basestring):
        from bzrlib.branch import Branch
        branch = Branch(branch)

    new_revno = branch.revno()
    if cur_revno == new_revno:
        print '** tree is up-to-date'

    if verbose:
        if cur_revno != new_revno:
            from bzrlib.log import show_log
            show_log(branch, direction='forward',
                    start_revision=cur_revno+1, end_revision=new_revno)

    return branch


def push(branch, remote, verbose=False, dry_run=False):
    """Update the local repository from the location specified by 'remote'

    :param branch:  Should always be a Branch object
    """
    if isinstance(branch, basestring):
        from bzrlib.errors import BzrError
        raise BzrError('rsync push requires a Branch object, not a string')
    local = branch.base
    if remote[-1:] != '/':
        remote += '/'

    rsyncopts = ['-rltp', '--include-from -'
        , '--include .bzr'
        # We don't want to push our local meta information to the remote
        , "--exclude '.bzr/x-rsync*'", "--exclude '.bzr/x-pull*'" 
        , "--exclude '.bzr/parent'", "--exclude '.bzr/pull'"
        , "--include '.bzr/**'"
        , "--exclude '*'", "--exclude '.*'"
        , '--delete', '--delete-excluded'
        ]

    rsync_exclude = os.path.join(local, '.rsyncexclude')
    if os.path.exists(rsync_exclude):
        rsyncopts.append('--exclude-from "%s"' % rsync_exclude)
    bzr_ignore = os.path.join(local, '.bzrignore')
    if os.path.exists(bzr_ignore):
        rsyncopts.append('--exclude-from "%s"' % bzr_ignore)

    if verbose:
        rsyncopts.append('-v')
    if dry_run:
        rsyncopts.append('--dry-run')

    cmd = 'rsync %s "." "%s"' % (' '.join(rsyncopts), remote)
    if verbose:
        print cmd

    pwd = os.getcwd()
    try:
        os.chdir(local)
        child = os.popen(cmd, 'w')
        inv = branch.read_working_inventory()
        for path, entry in inv.entries():
            child.write(path)
            child.write('\n')
        child.flush()
        retval = child.close()
        if retval is not None:
            from bzrlib.errors import BzrError
            raise BzrError('Rsync failed with error code: %s' % retval)
    finally:
        os.chdir(pwd)