# -*- coding: utf-8 -*-
import time
from threading import Lock
from collections import deque

import opuslib

from .constants import *


class SoundQueue:
    """
    Per user storage of received audio frames
    Takes care of the decoding of the received audio
    """
    def __init__(self, mumble_object):
        self.mumble_object = mumble_object
        
        self.queue = deque()
        self.start_sequence = None
        self.start_time = None

        self.receive_sound = True
        
        self.lock = Lock()
        
        # to be sure, create every supported decoders for all users
        # sometime, clients still use a codec for a while after server request another...
        self.decoders = {
                    PYMUMBLE_AUDIO_TYPE_OPUS: opuslib.Decoder(PYMUMBLE_SAMPLERATE, 1)
        }

    def set_receive_sound(self, value):
        """Define if received sounds must be kept or discarded in this specific queue (user)"""
        if value:
            self.receive_sound = True
        else:
            self.receive_sound = False

    def add(self, audio, sequence, type, target):
        """Add a new audio frame to the queue, after decoding"""
        if not self.receive_sound:
            return None
        
        self.lock.acquire()
        
        try:
            pcm = self.decoders[type].decode(audio, PYMUMBLE_READ_BUFFER_SIZE)

            if not self.start_sequence or sequence <= self.start_sequence:
                # New sequence started
                self.start_time = time.time()
                self.start_sequence = sequence
                calculated_time = self.start_time
            else:
                # calculating position in current sequence
                calculated_time = self.start_time + (sequence - self.start_sequence) * PYMUMBLE_SEQUENCE_DURATION

            newsound = SoundChunk(pcm, sequence, len(pcm), calculated_time, type, target)

            if not self.mumble_object.callbacks.get_callback(PYMUMBLE_CLBK_SOUNDRECEIVED):
                self.queue.appendleft(newsound)

                if len(self.queue) > 1 and self.queue[0].time < self.queue[1].time:
                    # sort the audio chunk if it came out of order
                    cpt = 0
                    while cpt < len(self.queue) - 1 and self.queue[cpt].time < self.queue[cpt+1].time:
                        tmp = self.queue[cpt+1]
                        self.queue[cpt+1] = self.queue[cpt]
                        self.queue[cpt] = tmp

            self.lock.release()
            return newsound
        except KeyError:
            self.lock.release()
            self.mumble_object.Log.error("Codec not supported (audio packet type {0})".format(type))
        except Exception as e:
            self.lock.release()
            self.mumble_object.Log.error("error while decoding audio. sequence:{seq}, type:{type}. {error}".format(seq=sequence, type=type, error=str(e)))

    def is_sound(self):
        """Boolean to check if there is a sound frame in the queue"""
        if len(self.queue) > 0:
            return True
        else:
            return False
        
    def get_sound(self, duration=None):
        """Return the first sound of the queue and discard it"""
        self.lock.acquire()

        if len(self.queue) > 0:
            if duration is None or self.first_sound().duration <= duration:
                result = self.queue.pop() 
            else:
                result = self.first_sound().extract_sound(duration)
        else:
            result = None

        self.lock.release()
        return result
    
    def first_sound(self):
        """Return the first sound of the queue, but keep it"""
        if len(self.queue) > 0:
            return self.queue[-1]
        else:
            return None
        

class SoundChunk:
    """
    Object that contains the actual audio frame, in PCM format"""    
    def __init__(self, pcm, sequence, size, calculated_time, type, target, timestamp=time.time()):
        self.timestamp = timestamp  # measured time of arrival of the sound 
        self.time = calculated_time  # calculated time of arrival of the sound (based on sequence)
        self.pcm = pcm  # audio data
        self.sequence = sequence  # sequence of the packet
        self.size = size  # size
        self.duration = float(size) / 2 / PYMUMBLE_SAMPLERATE  # duration in sec
        self.type = type  # type of the audio (codec)
        self.target = target  # target of the audio
        
    def extract_sound(self, duration):
        """Extract part of the chunk, leaving a valid chunk for the remaining part"""
        size = int(duration*2*PYMUMBLE_SAMPLERATE)
        result = SoundChunk(
                        self.pcm[:size],
                        self.sequence,
                        size,
                        self.time,
                        self.type,
                        self.target,
                        self.timestamp
                        )
        
        self.pcm = self.pcm[size:]
        self.duration -= duration
        self.time += duration
        self.size -= size
        
        return result