# -*- coding: utf-8 -*-

from django.db import models
from django.contrib import auth
from django.conf import settings

from ToramaNg.biblio.models import *
from ToramaNg.biblio.validators import *
from ToramaNg.biblio.handlers import *

import django.contrib.auth

import os
import random

import mutagen.oggvorbis


# Managers 
class ConvertedOrphanSentFiles(models.Manager):
    def get_query_set(self):
        tmp = super(ConvertedOrphanSentFiles, self).get_query_set()
        tmp = tmp.exclude(final_file='')
        i =0
        while i < tmp.count() :
            try:
                tmp[i].oggfile_set
                del tmp[i]
            except AttributeError:
                pass
            i += 1
        return tmp


## Gestion de l'upload et de la conversion

class SentFile(models.Model):
    temp_file = models.FileField(upload_to="queue/",validator_list=[isSupportedFormat,])
    send_date = models.DateTimeField(auto_now_add=True,editable=False)
    final_file = models.FilePathField(path=settings.CONVERTED_PATH,match=r'.*\.ogg',blank=True,core=False,editable=True)
    # Class constant
    READABLE_STATE = {'Q':'En attente','P':'En cours de traitement','F': 'Échoué','D':'Succès'}
    objects = models.Manager()
    orphans_objects = ConvertedOrphanSentFiles()
    
    def __str__(self):
        if self.final_file:
            return self.final_file.split("/")[-1]
        else:
            return self.temp_file.split("/")[-1]

    def convert(self):
        # A validator verified before that the file extension is
        # supported
        handler =self.myHandler()
        ogg_list = handler.giveMeOgg()
        if ogg_list:
            for path in ogg_list:
                new_path = os.path.join(settings.CONVERTED_PATH,os.path.basename(path))
                os.renames(path,new_path)
                self.final_file = new_path
                self.save()
        else:
            raise TypeError, 'Erreur du gestionnaire %s.'%str(type(handler))


    def myHandler(self):
        extension = self.temp_file.split('.')[-1]
        for handler in settings.HANDLERS:
            if extension in handler.extensions:
                return handler(self)


    def printState(self):
        handler =self.myHandler()
        return self.READABLE_STATE[handler.getState()]
        
    def processButton(self):
        handler =self.myHandler()
        """Permet d'afficher dans le détail de la page d'admin un lien
        pour traiter the file
        """
        if handler.getState() == 'Q':
            return '<a href="%s/process">convertir</a>'%(self.id)
        elif handler.getState() == 'F':
            return '<a href="%s/process"></a>'%(self.id)
        else:
            return ''
    processButton.allow_tags=True
    processButton.short_description=u'Traiter'



    class Meta:
        permissions = (
            ("can_process", "Can Launch processing on uploaded files"),
        )

    class Admin:
        list_display = ('__str__','processButton','send_date','printState')






class License(models.Model):
    name = models.CharField(maxlength=120,core=True)
    url =  models.URLField(verify_exists=True,core=True)
    def __str__(self):
        return self.name
    class Admin:
        pass

class Album(models.Model):
    nom = models.CharField(maxlength=60)
    image = models.ImageField(upload_to="covers/",blank=True)
            
    class Admin:
        pass

    def __str__(self):
        return self.nom

    def getArtists(self):
        return set([track.artist for track in self.tracks])


    def getImage(self):
        if self.image:
            return self.image
        else:
            return self.tracks[0].artists[0].image

    
class Artist(models.Model):
    name = models.CharField(maxlength=60)
    localisation = models.CharField(maxlength=50,blank=True)
    description = models.TextField(maxlength=500,blank=True)
    url = models.URLField(maxlength=60)
    image = models.ImageField(upload_to=settings.COVERS_PATH,blank=True)
    
    def __str__(self):
        return self.name
    class Admin:
        pass

    def getImage(self):
        return self.image

class OggFile(models.Model):
    audio_file = models.ForeignKey('SentFile',choices=[(i,str(i)) for i in SentFile.orphans_objects.all()])
    title = models.CharField(maxlength=60)
    artist = models.ManyToManyField(Artist,core=False,blank=False,related_name='artists')
    album = models.ForeignKey(Album,core=False,blank=True,null=True,related_name='tracks')
    license = models.ForeignKey(License,core=False,blank=False)
    image = models.ImageField(upload_to=settings.COVERS_PATH,blank=True)
    length = models.FloatField(max_digits=18,decimal_places=14)
    can_download = models.BooleanField()
    public_metadata = models.BooleanField()

    class Meta:
        ordering = ('title',)

    class Admin:
        pass

    def __str__(self):
        return self.title

    def save(self):
        self.setMetasFromVorbis()
        models.Model.save(self)


    def getImage(self):
        if self.image:
            return self.image
        else:
            return self.album.getImage()
    
    def getOggPath(self):
        return self.audio_file.final_file
    
    def setMetasFromVorbis(self):
        metas = self.openMetas()
        self.title = self.getMetaKey('Title')
        self.length = metas.info.length

    def openMetas(self):
        try:
            return self.meta
        except AttributeError:
            self.meta = mutagen.oggvorbis.Open(self.getOggPath())
            return self.meta


    def getMetaKey(self,key):
        try:
            return self.openMetas()[key][0]
        except KeyError:
            return ''