import os
from flask import Flask, Response, request
import re
import json
import click
from time import time
from flask import send_from_directory

def which(*names):
    for d in os.environ.get("PATH").split(":"):
        for name in names:
            path = os.path.join(d, name)
            if os.path.exists(path):
                return  path
    raise ValueError("Couldn't find %s anywhere in $PATH" % names)

MADPLAY = which("madplay")
CURL = which("curl")
FLAC = which("flac")
LAME = which("lame")
FFMPEG = which("avconv", "ffmpeg")
OGGDEC = which("oggdec")
OGGENC = which("oggenc")

TYPES = {
    "mp3": "audio/mpeg",
    "flac": "audio/flac",
    "oga": "audio/ogg",
    "ogg": "audio/ogg",
    "wma": "audio/x-ms-wma",
    "wav": "audio/wave",
}

RE_URL = re.compile(
    r'^https?://'  # http:// or https://
    r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|'  # domain...
    r'localhost|'  # localhost...
    r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|'  # ...or ipv4
    r'\[?[A-F0-9]*:[A-F0-9:]+\]?)'  # ...or ipv6
    r'(?::\d+)?'  # optional port
    r'(?:/?|[/?]\S+)$', re.IGNORECASE)

XML_ENTITIES = (
    ("&", "&"),
    ('"', """),
    ("'", "'"),
    (">", ">"),
    ("<", "&lt;"),
)

def escape_xml_entities(j):
    for letter, replacement in XML_ENTITIES:
        j = j.replace(letter, replacement)
    return j

def generate_xspf(root, names):
    names.sort()
    yield "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    yield "<playlist xmlns=\"http://xspf.org/ns/0/\" version=\"1\">"
    yield "<meta rel=\"timestamp\">%d</meta>" % time()
    yield "<trackList>"

    for name in names:
        path = os.path.join(root, name)
        basename, extension = os.path.splitext(name)

        import mutagen
        import mutagen.mp3

        try:
            if name.lower().endswith(".mp3"):
                tags = mutagen.mp3.EasyMP3(path)
            else:
                tags = mutagen.File(path)
        except mutagen.MutagenError:
            click.echo("Failed to parse metainformation for %s" % repr(path))

        # Fetch stream attributes
        sample_rate = getattr(tags.info, "sample_rate", None)
        duration = getattr(tags.info, "length", None)
        channels = getattr(tags.info, "channels", None)
        bitrate = getattr(tags.info, "bitrate", None)
        bit_depth = getattr(tags.info, "bits_per_sample", None)


        # Workaround for calculating bitrate
        if not bitrate and duration:
            bitrate = int(item.size / duration) / 1000 * 8000

        # Artist
        artist_name = tags.pop("artist", (None,))[0]
        if not artist_name:
            artist_name = tags.pop("----:com.apple.iTunes:Artist Credit", (None,))[0]

        # Track album
        album_title = tags.pop("album", (None,))[0]
        if not album_title:
            album_title = tags.pop("----:com.apple.iTunes:Album Credit", (None,))[0]

        # Album artist
        album_artist_name = None
        if not album_artist_name:
            album_artist_name = tags.pop("----:com.apple.iTunes:Album Artist Credit", (None,))[0]

        # Track title
        track_title = tags.pop("title", (None,))[0]

        # Track year
        year, = tags.pop("date", (None,))
        if not year:
            year, = tags.pop("----:com.apple.iTunes:ORIGINAL YEAR", (None,))

        def parse_x_of_y(mixed):
            if not mixed:
                return None, None
            elif "\x00" in mixed: # Probably bug in mutagen
                return None, None
            elif re.match("\s*\d+\s*$", mixed):
                return int(mixed), None
            elif re.match("\s*\d+\s*/\s*\d+\s*$", mixed):
                return [int(j) for j in mixed.split("/", 1)]
            elif re.match("\s*/\s*\d+\s*$", mixed):
                return None, int(mixed.split("/", 1)[1])
            return None, None

        # Disc numbers
        disc_number, disc_count = None, None
        disc, = tags.pop("discnumber", (None,))
        if disc:
            disc_number, disc_count = parse_x_of_y(disc)

        # Release country
        country_code, = tags.pop("releasecountry", (None,))
        if not country_code:
            country_code, = tags.pop("----:com.apple.iTunes:MusicBrainz Album Release Country", (None,))

        # Track number could be in various formats: '1', '1/12', 'B2'
        track_number = tags.pop("tracknumber", (None,))[0]
        track_number, track_count = parse_x_of_y(track_number)
        if not track_number:
            (track_number, track_count), = tags.pop("trkn", ((None,None),))

        # Normalize country code
        if country_code:
            country_code = country_code.lower()
            if country_code in ("xe", "xw"):
                country_code = None

        yield "<track>"
        yield "<location>%s</location>" % escape_xml_entities(name)

        if duration:
            yield "<duration>%d</duration>" % (duration * 1000)

        if track_title:
            yield "<title>%s</title>" %  escape_xml_entities(track_title)
            if artist_name:
                yield "<creator>%s</creator>" % escape_xml_entities(artist_name)
            if album_title:
                yield "<album>%s</album>" % escape_xml_entities(album_title)
        else:
            yield "<title>%s</title>" %  escape_xml_entities(basename)


        if track_number:
            yield "<trackNum>%d</trackNum>" % track_number


        if track_count:
            yield "<meta rel=\"track-count\">%d</meta>" % track_count
        if disc_number:
            yield "<meta rel=\"disc-number\">%d</meta>" % disc_number
        if disc_count:
            yield "<meta rel=\"disc-count\">%d</meta>" % disc_count

        if year:
            yield "<meta rel=\"year\">%s</meta>" % year

        if album_artist_name:
            yield "<meta rel=\"album-artist\">%s</meta>" % escape_xml_entities(album_artist_name)
        yield "<meta rel=\"mimetype\">%s</meta>" % TYPES[extension[1:].lower()]
        yield "<meta rel=\"bitrate\">%s</meta>" % bitrate
        yield "<meta rel=\"bit_depth\">%s</meta>" % bit_depth
        yield "<meta rel=\"sample_rate\">%s</meta>" % sample_rate

        yield "</track>"
    yield "</trackList>"
    yield "</playlist>"


@click.command("metagen")
@click.option('--root', '-r', prompt='Path to media directory', help='Root directory to index')
@click.option('--force', '-f', is_flag=True, help="Reindex even if up to date according to timestamps")
def metagen(root, force):
    for abspath, dirs, files in os.walk(root):
        playlist = os.path.join(abspath, "index.xspf")
        needed = False
        relevant_files = []
        for name in files:
            for extension, mimetype in TYPES.items():
                if name.lower().endswith("." + extension):
                    needed = True
                    relevant_files.append(name)

        if "index.xspf" in files:
            # TODO proper handling here, microsecond differences
            if not force and int(os.stat(abspath).st_mtime) <= int(os.stat(playlist).st_mtime):
                click.echo("Folder %s is up to date" % repr(abspath))
                needed = False
            if not relevant_files:
                click.echo("No more relevant files, removing %s" % playlist)
                os.remove(playlist)

        if "index.xspf.part" in files:
            click.echo("Cleaning up %s.part" % playlist)
            os.remove(playlist + ".part")
        if needed:
            with open(playlist + ".part", "w") as fh:
                for chunk in generate_xspf(abspath, relevant_files):
                    fh.write(chunk)
            os.rename(playlist + ".part", playlist)
            click.echo("Generated %s" % repr(playlist))



@click.command("serve")
@click.option('--root', prompt='Path to media directory', help='Root directory to serve')
def serve(root):
    app = Flask(__name__)

    @app.route("/api/transcode/")
    def transcode():
        def build_pipeline(source, output_mimetype):
            sys.stderr.write("Transcoding from: %s\n" % source)
            basename, extension = os.path.splitext(source)
            extension = extension.lower()

            try:
                input_mimetype = TYPES.get(extension)
            except:
                raise ValueError("Unknown input file extension:", extension)

            sys.stderr.write("Input mimetype: %s\n" %  input_mimetype)
            sys.stderr.write("Output mimetype: %s\n" %  output_mimetype)

            pipeline = []
            if source.startswith("http://") or source.startswith("https://"):
                # Escape path component
                url = urlparse.urlparse(source)
                source = url.scheme + "://" + url.hostname.encode("idna") + urllib.quote(url.path)
                yield CURL, "--insecure", "--silent", "--limit-rate", "300k", source # 1Mbps is pretty max
            else:
                # Perhaps we could read file directly here if transcoder and web server are in the same machine?
                raise ValueError("Won't transcode:" + source)

            if input_mimetype == "audio/wave":
                pass # Do nothing
            elif input_mimetype == "audio/mpeg":
                yield MADPLAY, "-", "-o", "wave:-"
            elif input_mimetype == "audio/ogg":
                yield OGGDEC, "-", "-o", "-"
            elif input_mimetype == "audio/flac":
                if output_mimetype != "audio/ogg": # oggenc handles FLAC input aswell
                    yield FLAC, "--decode", "-", "--stdout", "--silent"
            else:
                # Use FFMPEG/avconv as fallback for decoding wma
                yield FFMPEG, "-i", "-", "-f", "wav", "-", "-loglevel", "quiet"

            if output_mimetype == "audio/wave":
                pass
            elif output_mimetype == "audio/mpeg":
                yield LAME, "--quiet", "-aq", "2", "-", "-"
            elif output_mimetype == "audio/ogg":
                yield OGGENC, "-", "-o", "-"
            else:
                raise ValueError("Don't know how to encode mimetype: %s" % output_mimetype)


        mimetype = request.args.get("mimetype")

        pipeline = tuple(build_pipeline(request.args.get("url"), mimetype))

        first = True
        for element in pipeline:
            if not first:
                print("|",)
            first = False
            print(" ".join(repr(j) if " " in j else j for j in element))
        print()

        process = None
        for element in pipeline:
            process = Popen(element, stdout=PIPE, stdin=process.stdout if process else PIPE, close_fds=True)

        return send_file(process.stdout, "stream", mimetype)


    @app.route("/api/search/")
    def search():
        expr = re.compile(request.args.get('expr', 'metallica'), re.IGNORECASE)
        limit = request.args.get('limit', 100)

        def generate():
            yield 'retry:999999999999\n' # Tell browser to never reconnect
            total = 0
            hits = 0
            counter = 0

            for abspath, dirs, files in os.walk(root):
                dirs.sort()
                relpath = os.path.relpath(abspath, root)
                hit = False
                filtered_filenames = []
                for name in files:
                    lower_name = name.lower()
                    for extension, mimetype in TYPES.items():
                        if lower_name.endswith("." + extension):
                            filtered_filenames.append(name)
                            total += 1
                    if expr.search(name):
                        hit = True
                        hits += 1

                if expr.search(relpath):
                   hit = True

                if hit and filtered_filenames:
                    yield "event:chdir\ndata:"
                    yield relpath
                    yield "\n\n"
                    yield "event:xspf\n"
                    yield "data:"
                    if "index.xspf" in files:
                        with open(os.path.join(abspath, "index.xspf")) as fh:
                            yield fh.read()
                    else:
                        yield from generate_xspf(abspath, filtered_filenames)
                    yield "\n"
                    yield "\n"
                    counter += 1
                    if counter > limit:
                        break
                if counter > limit:
                    break

            yield "event:done\n"
            yield "data:%s\n" % json.dumps({"relevant_files":total, "hits":hits})
            yield "\n"
        return Response(generate(), mimetype='text/event-stream')

    @app.route('/api/stream/<path:path>')
    def send_stream(path):
        return send_from_directory(root, path)


    @app.route('/<path:path>')
    def send_js(path):
        return send_from_directory('static', path)

    app.run(host= '0.0.0.0', debug=True, threaded=True)

@click.group()
def entry_point(): pass

entry_point.add_command(serve)
entry_point.add_command(metagen)

if __name__ == '__main__':
    entry_point()