#!/usr/bin/python

import os

import sqlite

from ogg.vorbis import VorbisFile

import ID3

import readline

import imms

from utils import unique, copy_file, set_file_completer

class CleanupIMMS:

    def __init__(self, db_file):

        self.db = imms.IMMSDb(db_file)

    def check_uid(self, uid):

        lib = self.db.get_library_entries(uid = uid)

        if len(lib) == 0:

            print "Erased uid = ", uid

            self.db.erase_uid(uid)

    def check_sid(self, sid):

        lib = self.db.get_library_entries(sid = sid)

        if len(lib) == 0:

            print "Erased sid = ", uid

            self.db.erase_sid(sid)

    def handle_no_file(self, path, uid, sid):

        other_paths = self.db.get_library_entries(uid = uid)

        other_paths = unique(map(lambda x: x[0], other_paths))

        for opath in other_paths:

            if os.path.isfile(opath):

                return None

        other_paths = self.db.get_library_entries(sid = sid)

        other_paths = unique(map(lambda x: x[0], other_paths))

        for opath in other_paths:

            if os.path.isfile(opath):

                readline.add_history(opath)

        readline.add_history(path)

        readline.insert_text('Edit')

        while 1:

            cmd = raw_input("I can't find '%s'.\n"

                            "Edit, Skip or Remove? " % path)

            if len(cmd) > 0:

                cmd = cmd.lstrip()[0].lower()

                if cmd == 'e':

                    newpath = raw_input()

                    if newpath in other_paths:

                        return None

                    if os.path.isfile(newpath):

                        return newpath

                    print "Invalid filename!"

                elif cmd == 's':

                    return path;

                elif cmd == 'r':

                    return None

    def clean_library(self):

        lib = self.db.get_library_entries()

        deleted_uids = []

        deleted_sids = []

        for entry in lib:

            path, uid, sid = entry

            if not os.path.isfile(path):

                uid = int(uid)

                sid = int(sid)

                newfile = self.handle_no_file(path, uid, sid)

                if not newfile:

                    print "Erasing ", path

                    self.db.erase_filename(path)

                    deleted_uids.append(uid)

                    deleted_sids.append(sid)

                elif newfile != path:

                    print "Renaming ", path, " into ", newfile

                    self.db.update_filename(path, newfile)

                else:

                    print "Skipping ", path

        map(self.check_uid, unique(deleted_uids))

        map(self.check_sid, unique(deleted_sids))

    def clean_rating(self):

        rates = self.db.get_ratings()

        rates = unique(map(lambda x: x[0], rates))

        map(self.check_uid, rates)

    def clean_acoustic(self):

        uids = map(lambda x: x[0], self.db.get_acoustics())

        map(self.check_uid, uids)

    def clean_info(self):

        sids = map(lambda x: x[0], self.db.get_infos())

        map(self.check_sid, sids)

    def clean_last(self):

        sids = map(lambda x: x[0], self.db.get_last())

        map(self.check_sid, sids)

    def clean_all(self):

        self.clean_library()

        self.clean_rating()

        self.clean_acoustic()

        self.clean_info()

        self.clean_last()

if __name__ == '__main__':

    set_file_completer()

    readline.parse_and_bind('tab: complete')

    db_file = os.environ['HOME'] + '/.imms/imms.db'

    db_backup = db_file + '.bak'

    copy_file(db_file, db_backup).close()

    try:

        clean_up = CleanupIMMS(db_file)

    except Exception, inst:

        print inst

        ans = raw_input('Do you want to get back the backup file? ')

        if len(ans) > 0:

            if ans.lstrip()[0].lower() == 'y':

                copy_file(db_backup, db_file)

    print "backup file preserved: %s." % db_backup