r"""
Work with WAV files

A WAV file is a header specifying format information, followed by a
sequence of bytes, representing the state of some audio signal over a
length of time.

A WAV file may have any number of channels. Typically, they have 1
(mono) or 2 (for stereo). The data of a WAV file is given as a
sequence of frames. A frame consists of samples. There is one sample
per channel, per frame. Every wav file has a sample width, or, the
number of bytes per sample. Typically this is either 1 or 2 bytes.

The wav module supplies more convenient access to this data. In
particular, see the docstring for ``Wave.channel_data()``.

The header contains information necessary for playing the WAV file,
including the number of frames per second, the number of bytes per
sample, and the number of channels in the file.

AUTHORS:

- Bobby Moretti and Gonzalo Tornaria (2007-07-01): First version
- William Stein (2007-07-03): add more
- Bobby Moretti (2007-07-03): add doctests
"""
from __future__ import print_function
from __future__ import absolute_import
from six.moves import range

import math
import os
import wave

from sage.plot.plot import list_plot
from sage.structure.sage_object import SageObject
from sage.arith.srange import srange
from sage.misc.html import html
from sage.rings.all import RDF

class Wave(SageObject):
    """
    A class wrapping a wave audio file.

    INPUT:

    You must call Wave() with either data = filename, where
    filename is the name of a wave file, or with each of the
    following options:

    - channels  -- the number of channels in the wave file (1 for mono, 2 for
      stereo, etc...
    - width     -- the number of bytes per sample
    - framerate -- the number of frames per second
    - nframes   -- the number of frames in the data stream
    - bytes     -- a string object containing the bytes of the data stream

    Slicing:

        Slicing a Wave object returns a new wave object that has been
        trimmed to the bytes that you have given it.

    Indexing:

        Getting the $n$th item in a Wave object will give you the value
        of the $n$th frame.
    """
    def __init__(self, data=None, **kwds):
        if data is not None:
            self._filename = data
            self._name = os.path.split(data)[1]
            wv = wave.open(data, "rb")
            self._nchannels = wv.getnchannels()
            self._width = wv.getsampwidth()
            self._framerate = wv.getframerate()
            self._nframes = wv.getnframes()
            self._bytes = wv.readframes(self._nframes)
            from .channels import _separate_channels
            self._channel_data = _separate_channels(self._bytes,
                                                   self._width,
                                                   self._nchannels)
            wv.close()
        elif kwds:
            try:
                self._name = kwds['name']
                self._nchannels = kwds['nchannels']
                self._width = kwds['width']
                self._framerate = kwds['framerate']
                self._nframes = kwds['nframes']
                self._bytes = kwds['bytes']
                self._channel_data = kwds['channel_data']
            except KeyError as msg:
                raise KeyError(msg + " invalid input to Wave initializer")
        else:
            raise ValueError("Must give a filename")


    def save(self, filename='sage.wav'):
        r"""
        Save this wave file to disk, either as a Sage sobj or as a .wav file.

        INPUT:
            filename -- the path of the file to save. If filename ends
                        with 'wav', then save as a wave file,
                        otherwise, save a Sage object.

            If no input is given, save the file as 'sage.wav'.

        """
        if not filename.endswith('.wav'):
            SageObject.save(self, filename)
            return
        wv = wave.open(filename, 'wb')
        wv.setnchannels(self._nchannels)
        wv.setsampwidth(self._width)
        wv.setframerate(self._framerate)
        wv.setnframes(self._nframes)
        wv.writeframes(self._bytes)
        wv.close()

    def listen(self):
        """
        Listen to (or download) this wave file.

        Creates a link to this wave file in the notebook.
        """
        from sage.misc.html import html
        i = 0
        fname = 'sage%s.wav'%i
        while os.path.exists(fname):
            i += 1
            fname = 'sage%s.wav'%i

        self.save(fname)
        return html('<a href="cell://%s">Click to listen to %s</a>'%(fname, self._name))

    def channel_data(self, n):
        """
        Get the data from a given channel.

        INPUT:
            n -- the channel number to get

        OUTPUT:
            A list of signed ints, each containing the value of a frame.
        """
        return self._channel_data[n]


    def getnchannels(self):
        """
        Returns the number of channels in this wave object.

        OUTPUT:
            The number of channels in this wave file.
        """
        return self._nchannels

    def getsampwidth(self):
        """
        Returns the number of bytes per sample in this wave object.

        OUTPUT:
            The number of bytes in each sample.
        """
        return self._width

    def getframerate(self):
        """
        Returns the number of frames per second in this wave object.

        OUTPUT:
            The frame rate of this sound file.
        """
        return self._framerate

    def getnframes(self):
        """
        The total number of frames in this wave object.

        OUTPUT:
            The number of frames in this WAV.
        """
        return self._nframes

    def readframes(self, n):
        """
        Reads out the raw data for the first $n$ frames of this wave
        object.

        INPUT:
            n -- the number of frames to return

        OUTPUT:
            A list of bytes (in string form) representing the raw wav data.
        """
        return self._bytes[:nframes*self._width]

    def getlength(self):
        """
        Returns the length of this file (in seconds).

        OUTPUT:
            The running time of the entire WAV object.
        """
        return float(self._nframes) / (self._nchannels * float(self._framerate))

    def _repr_(self):
        nc = self.getnchannels()
        return "Wave file %s with %s channel%s of length %s seconds%s" % \
        (self._name, nc, "" if nc == 1 else "s", self.getlength(), "" if nc == 1 else " each")

    def _normalize_npoints(self, npoints):
        """
        Used internally while plotting to normalize the number of
        """
        return npoints if npoints else self._nframes

    def domain(self, npoints=None):
        """
        Used internally for plotting. Get the x-values for the various points to plot.
        """
        npoints = self._normalize_npoints(npoints)
        # figure out on what intervals to sample the data
        seconds = float(self._nframes) / float(self._width)
        frame_duration = seconds / (float(npoints) * float(self._framerate))

        domain = [n * frame_duration for n in range(npoints)]
        return domain

    def values(self, npoints=None, channel=0):
        """
        Used internally for plotting. Get the y-values for the various points to plot.
        """
        npoints = self._normalize_npoints(npoints)

        # now, how many of the frames do we sample?
        frame_skip = int(self._nframes / npoints)
        # the values of the function at each point in the domain
        cd = self.channel_data(channel)

        # now scale the values
        scale = float(1 << (8*self._width -1))
        values = [cd[frame_skip*i]/scale for i in range(npoints)]
        return values

    def set_values(self, values, channel=0):
        """
        Used internally for plotting. Get the y-values for the various points to plot.
        """
        c = self.channel_data(channel)
        npoints = len(c)
        if len(values) != npoints:
            raise ValueError("values (of length %s) must have length %s"%(len(values), npoints))

        # unscale the values
        scale = float(1 << (8*self._width -1))
        values = [float(abs(s)) * scale for s in values]

        # the values of the function at each point in the domain
        c = self.channel_data(channel)
        for i in range(npoints):
            c[i] = values[i]

    def vector(self, npoints=None, channel=0):
        npoints = self._normalize_npoints(npoints)

        V = RDF**npoints
        return V(self.values(npoints=npoints, channel=channel))

    def plot(self, npoints=None, channel=0, plotjoined=True, **kwds):
        """
        Plots the audio data.

        INPUT:

        - npoints -- number of sample points to take; if not given, draws all
          known points.
        - channel -- 0 or 1 (if stereo).  default: 0
        - plotjoined -- whether to just draw dots or draw lines between sample points

        OUTPUT:

        a plot object that can be shown.
        """

        domain = self.domain(npoints = npoints)
        values = self.values(npoints=npoints, channel = channel)
        points = zip(domain, values)

        L = list_plot(points, plotjoined=plotjoined, **kwds)
        L.xmin(0)
        L.xmax(domain[-1])
        return L

    def plot_fft(self, npoints=None, channel=0, half=True, **kwds):
        v = self.vector(npoints=npoints)
        w = v.fft()
        if half:
            w = w[:len(w)//2]
        z = [abs(x) for x in w]
        if half:
            r = math.pi
        else:
            r = 2*math.pi
        data = zip(srange(0, r, r/len(z)),  z)
        L = list_plot(data, plotjoined=True, **kwds)
        L.xmin(0)
        L.xmax(r)
        return L

    def plot_raw(self, npoints=None, channel=0, plotjoined=True, **kwds):
        npoints = self._normalize_npoints(npoints)
        seconds = float(self._nframes) / float(self._width)
        sample_step = seconds / float(npoints)
        domain = [float(n*sample_step) / float(self._framerate) for n in range(npoints)]
        frame_skip = self._nframes / npoints
        values = [self.channel_data(channel)[frame_skip*i] for i in range(npoints)]
        points = zip(domain, values)

        return list_plot(points, plotjoined=plotjoined, **kwds)

    def __getitem__(self, i):
        """
        Returns the `i`-th frame of data in the wave, in the form of a string,
        if `i` is an integer.
        Returns a slice of self if `i` is a slice.
        """
        if isinstance(i, slice):
            start, stop, step = i.indices(self._nframes)
            return self._copy(start, stop)
        else:
            n = i*self._width
            return self._bytes[n:n+self._width]

    def slice_seconds(self, start, stop):
        """
        Slices the wave from start to stop.

        INPUT:
            start -- the time index from which to begin the slice (in seconds)
            stop -- the time index from which to end the slice (in seconds)

        OUTPUT:
            A Wave object whose data is this object's data,
            sliced between the given time indices
        """
        start = int(start*self.getframerate())
        stop = int(stop*self.getframerate())
        return self[start:stop]

    # start and stop are frame numbers
    def _copy(self, start, stop):
        start = start * self._width
        stop = stop * self._width
        channels_sliced = [self._channel_data[i][start:stop] for i in range(self._nchannels)]
        print(stop - start)

        return Wave(nchannels = self._nchannels,
                    width = self._width,
                    framerate = self._framerate,
                    bytes = self._bytes[start:stop],
                    nframes = stop - start,
                    channel_data = channels_sliced,
                    name = self._name)

    def __copy__(self):
        return self._copy(0, self._nframes)

    def convolve(self, right, channel=0):
        """
        NOT DONE!

        Convolution of self and other, i.e., add their fft's, then
        inverse fft back.
        """
        if not isinstance(right, Wave):
            raise TypeError("right must be a wave")
        npoints = self._nframes
        v = self.vector(npoints, channel=channel).fft()
        w = right.vector(npoints, channel=channel).fft()
        k = v + w
        i = k.inv_fft()
        conv = self.__copy__()
        conv.set_values(list(i))
        conv._name = "convolution of %s and %s"%(self._name, right._name)
        return conv
