import dircache, os.path
from sys import stderr
import readline

def sql_quote(str):
    return str.replace("'", "''")

def get_song_info(path):
    "Return (artist, title) pair from path."
    artist, title = None, None
    if os.path.isfile(path):
        if path[-4:] == '.mp3':
            from ID3 import ID3
            id3 = ID3(path)
            try:
                artist = id3['ARTIST']
            except:
                pass
            try:
                title = id3['TITLE']
            except:
                pass
        elif path[-4:] == '.ogg':
            from ogg.vorbis import VorbisFile
            vf = VorbisFile(path)
            vc = vf.comment()
            try:
                artist = vc['ARTIST'][0]
            except:
                pass
            try:
                title = vc['TITLE'][0]
            except:
                pass
    return artist, title

def strdelay(seconds):
    secs = abs(round(seconds))
    minutes = secs / 60;
    hours = minutes / 60;
    days = hours / 24;
    secs = secs % 60;
    minutes %= 60;
    hours %= 24;

    if seconds < 0:
            s = "-"
    else:
            s = ""
    if days >= 1:
            s += "%dd %dh" % (days, hours)
    elif hours >= 1:
            s += "%dh%02d" % (hours, minutes)
    elif minutes >= 1:
            s += "%d'%02d\"" % (minutes, secs)
    else:
            s += "%d\"" % (secs)
    return s

def set_file_completer():
    readline.set_completer_delims('')
    readline.set_completer(_file_completer)

def _file_completer(text, state):
    dirname, filename = os.path.split(text)
    if not os.path.isdir(dirname):
        return None
    paths = dircache.listdir(dirname)
    tlen = len(filename)
    checkpaths = []
    if tlen > 0:
        for fn in paths:
            if fn[:len(filename)] == filename:
                checkpaths.append(fn)
    else:
        checkpaths = paths
    if len(checkpaths) > state:
        return os.path.join(dirname, checkpaths[state])
    return None
    
def copy_file(origname, copyname):
    orig = file(origname, 'r')
    new = file(copyname, 'w')
    new.write(orig.read())
    new.flush()
    return new

def unique(s):
    """Return a list of the elements in s, but without duplicates.

    For example, unique([1,2,3,1,2,3]) is some permutation of [1,2,3],
    unique("abcabc") some permutation of ["a", "b", "c"], and
    unique(([1, 2], [2, 3], [1, 2])) some permutation of
    [[2, 3], [1, 2]].

    For best speed, all sequence elements should be hashable.  Then
    unique() will usually work in linear time.

    If not possible, the sequence elements should enjoy a total
    ordering, and if list(s).sort() doesn't raise TypeError it's
    assumed that they do enjoy a total ordering.  Then unique() will
    usually work in O(N*log2(N)) time.

    If that's not possible either, the sequence elements must support
    equality-testing.  Then unique() will usually work in quadratic
    time.
    """

    n = len(s)
    if n == 0:
        return []

    # Try using a dict first, as that's the fastest and will usually
    # work.  If it doesn't work, it will usually fail quickly, so it
    # usually doesn't cost much to *try* it.  It requires that all the
    # sequence elements be hashable, and support equality comparison.
    u = {}
    try:
        for x in s:
            u[x] = 1
    except TypeError:
        del u  # move on to the next method
    else:
        return u.keys()

    # We can't hash all the elements.  Second fastest is to sort,
    # which brings the equal elements together; then duplicates are
    # easy to weed out in a single pass.
    # NOTE:  Python's list.sort() was designed to be efficient in the
    # presence of many duplicate elements.  This isn't true of all
    # sort functions in all languages or libraries, so this approach
    # is more effective in Python than it may be elsewhere.
    try:
        t = list(s)
        t.sort()
    except TypeError:
        del t  # move on to the next method
    else:
        assert n > 0
        last = t[0]
        lasti = i = 1
        while i < n:
            if t[i] != last:
                t[lasti] = last = t[i]
                lasti += 1
            i += 1
        return t[:lasti]

    # Brute force is all that's left.
    u = []
    for x in s:
        if x not in u:
            u.append(x)
    return u