"""
CAUTION: READ THIS CAREFULLY

Sometimes it happens that ldap (specifically ldapuser type) source
yield "ghost" users. The reasons may vary (server upgrade while some
instances are still running & syncing with the ldap source, unmanaged
updates to the upstream ldap, etc.).

This script was written and refined enough times that we are confident
in that it does something reasonnable (at least it did for the
target application).

However you should really REALLY understand what it does before
deciding to apply it for you. And then ADAPT it tou your needs.

"""

import base64
from collections import defaultdict

from cubicweb.server.session import hooks_control

try:
    source_name, = __args__
    source = repo.sources_by_uri[source_name]
except ValueError:
    print('you should specify the source name as script argument (i.e. after --'
          ' on the command line)')
    sys.exit(1)
except KeyError:
    print '%s is not an active source' % source_name
    sys.exit(1)

# check source is reachable before doing anything
if not source.get_connection().cnx:
    print '%s is not reachable. Fix this before running this script' % source_name
    sys.exit(1)

def find_dupes():
    # XXX this retrieves entities from a source name "ldap"
    #     you will want to adjust
    rset = sql("SELECT eid, extid FROM entities WHERE source='%s'" % source_name)
    extid2eids = defaultdict(list)
    for eid, extid in rset:
        extid2eids[extid].append(eid)
    return dict((base64.b64decode(extid).lower(), eids)
                for extid, eids in extid2eids.items()
                if len(eids) > 1)

def merge_dupes(dupes, docommit=False):
    gone_eids = []
    CWUser = schema['CWUser']
    for extid, eids in dupes.items():
        newest = eids.pop() # we merge everything on the newest
        print 'merging ghosts of', extid, 'into', newest
        # now we merge pairwise into the newest
        for old in eids:
            subst = {'old': old, 'new': newest}
            print '  merging', old
            gone_eids.append(old)
            for rschema in CWUser.subject_relations():
                if rschema.final or rschema == 'identity':
                    continue
                if CWUser.rdef(rschema, 'subject').composite == 'subject':
                    # old 'composite' property is wiped ...
                    # think about email addresses, excel preferences
                    for eschema in rschema.objects():
                        rql('DELETE %s X WHERE U %s X, U eid %%(old)s' % (eschema, rschema), subst)
                else:
                    # relink the new user to its old relations
                    rql('SET NU %s X WHERE NU eid %%(new)s, NOT NU %s X, OU %s X, OU eid %%(old)s' %
                        (rschema, rschema, rschema), subst)
                    # delete the old relations
                    rql('DELETE U %s X WHERE U eid %%(old)s' % rschema, subst)
            # same thing ...
            for rschema in CWUser.object_relations():
                if rschema.final or rschema == 'identity':
                    continue
                rql('SET X %s NU WHERE NU eid %%(new)s, NOT X %s NU, X %s OU, OU eid %%(old)s' %
                    (rschema, rschema, rschema), subst)
                rql('DELETE X %s U WHERE U eid %%(old)s' % rschema, subst)
    if not docommit:
        rollback()
        return
    commit() # XXX flushing operations is wanted rather than really committing
    print 'clean up entities table'
    sql('DELETE FROM entities WHERE eid IN (%s)' % (', '.join(str(x) for x in gone_eids)))
    commit()

def main():
    dupes = find_dupes()
    if not dupes:
        print 'No duplicate user'
        return

    print 'Found %s duplicate user instances' % len(dupes)

    while True:
        print 'Fix or dry-run? (f/d)  ... or Ctrl-C to break out'
        answer = raw_input('> ')
        if answer.lower() not in 'fd':
            continue
        print 'Please STOP THE APPLICATION INSTANCES (service or interactive), and press Return when done.'
        raw_input('<I swear all running instances and workers of the application are stopped>')
        with hooks_control(session, session.HOOKS_DENY_ALL):
            merge_dupes(dupes, docommit=answer=='f')

main()