/*
NAME
  audio-input.go

AUTHOR
  Trek Hopton <trek@ausocean.org>

LICENSE
  audio-input.go is Copyright (C) 2019 the Australian Ocean Lab (AusOcean)

  It is free software: you can redistribute it and/or modify them
  under the terms of the GNU General Public License as published by the
  Free Software Foundation, either version 3 of the License, or (at your
  option) any later version.

  It is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  for more details.

  You should have received a copy of the GNU General Public License in gpl.txt.
  If not, see [GNU licenses](http://www.gnu.org/licenses).
*/

package revid

import (
	"errors"
	"fmt"
	"io"
	"sync"
	"time"

	"github.com/yobert/alsa"

	"bitbucket.org/ausocean/av/codec/pcm"
	"bitbucket.org/ausocean/iot/pi/smartlogger"
	"bitbucket.org/ausocean/utils/logger"
	"bitbucket.org/ausocean/utils/ring"
)

const (
	logPath       = "/var/log/netsender"
	rbTimeout     = 100 * time.Millisecond
	rbNextTimeout = 100 * time.Millisecond
	rbLen         = 200
)

const (
	running = iota
	paused
	stopped
)

// Rates contains the audio sample rates used by revid.
var Rates = [8]int{8000, 16000, 32000, 44100, 48000, 88200, 96000, 192000}

var log *logger.Logger

// AudioDevice holds everything we need to know about the audio input stream.
// Note: At 44100 Hz sample rate, 2 channels and 16-bit samples, a period of 5 seconds
// results in PCM data chunks of 882000 bytes. A longer period exceeds datastore's 1MB blob limit.
type AudioDevice struct {
	mu     sync.Mutex
	source string // Name of audio source, or empty for the default source.
	mode   uint8  // Operating mode, either running, paused, or stopped.

	dev       *alsa.Device // Audio input device.
	ab        alsa.Buffer  // ALSA's buffer.
	rb        *ring.Buffer // Our buffer.
	chunkSize int          // This is the number of bytes that will be stored at a time.

	*AudioConfig
}

// AudioConfig provides parameters used by AudioDevice.
type AudioConfig struct {
	SampleRate int
	Channels   int
	BitDepth   int
	RecPeriod  float64
	Codec      uint8
}

// NewAudioDevice initializes and returns an AudioDevice struct which can be started, read from, and stopped.
func NewAudioDevice(cfg *AudioConfig) *AudioDevice {
	// Initialize logger.
	logLevel := int(logger.Debug)
	validLogLevel := true
	if logLevel < int(logger.Debug) || logLevel > int(logger.Fatal) {
		logLevel = int(logger.Info)
		validLogLevel = false
	}
	logSender := smartlogger.New(logPath)
	log = logger.New(int8(logLevel), &logSender.LogRoller)
	log.Log(logger.Info, "log-netsender: Logger Initialized")
	if !validLogLevel {
		log.Log(logger.Error, "Invalid log level was defaulted to Info")
	}

	a := &AudioDevice{}
	a.AudioConfig = cfg

	// Open the requested audio device.
	err := a.open()
	if err != nil {
		log.Log(logger.Fatal, "alsa.open failed", "error", err.Error())
	}

	// Setup ring buffer to capture audio in periods of a.RecPeriod seconds, and buffer rbDuration seconds in total.
	a.ab = a.dev.NewBufferDuration(time.Duration(a.RecPeriod * float64(time.Second)))
	cs := (float64((len(a.ab.Data)/a.dev.BufferFormat().Channels)*a.Channels) / float64(a.dev.BufferFormat().Rate)) * float64(a.SampleRate)
	if cs < 1 {
		log.Log(logger.Fatal, "given AudioConfig parameters are too small")
	}
	a.chunkSize = int(cs)
	a.rb = ring.NewBuffer(rbLen, a.chunkSize, rbTimeout)
	if a.rb == nil {
		fmt.Println("NEW:", "rb: NIL", a.mode)
		fmt.Println(rbLen, a.chunkSize, rbTimeout)
		fmt.Println(len(a.ab.Data), a.dev.BufferFormat().Channels, a.Channels, a.dev.BufferFormat().Rate, a.SampleRate)
	} else {
		fmt.Println("NEW:", "rb: VALID", a.mode)
	}
	a.mode = paused

	return a
}

// Start will start recording audio and writing to the output.
func (a *AudioDevice) Start() {
	fmt.Println("start lock")
	a.mu.Lock()
	switch a.mode {
	case paused:
		// Start Recording
		go a.input()
		a.mode = running
	case stopped:
		// Open the audio device and start recording.
		err := a.open()
		if err != nil {
			log.Log(logger.Fatal, "alsa.open failed", "error", err.Error())
		}
		go a.input()
		a.mode = running
	case running:
		return
	}
	a.mu.Unlock()
	fmt.Println("start unlock")
}

// Stop will stop recording audio and close the device
func (a *AudioDevice) Stop() {
	fmt.Println("stop lock")
	a.mu.Lock()
	if a.dev != nil {
		log.Log(logger.Debug, "Closing", "source", a.source)
		a.dev.Close()
		a.dev = nil
	}
	a.mode = stopped
	a.mu.Unlock()
	fmt.Println("stop unlock")

}

// ChunkSize returns the AudioDevice's chunkSize, ie. the number of bytes of audio written to output at a time.
func (a *AudioDevice) ChunkSize() int {
	return a.chunkSize
}

// open or re-open the recording device with the given name and prepare it to record.
// If name is empty, the first recording device is used.
func (a *AudioDevice) open() error {
	if a.dev != nil {
		log.Log(logger.Debug, "Closing", "source", a.source)
		a.dev.Close()
		a.dev = nil
	}
	log.Log(logger.Debug, "Opening", "source", a.source)

	cards, err := alsa.OpenCards()
	if err != nil {
		return err
	}
	defer alsa.CloseCards(cards)

	for _, card := range cards {
		devices, err := card.Devices()
		if err != nil {
			continue
		}
		for _, dev := range devices {
			if dev.Type != alsa.PCM || !dev.Record {
				continue
			}
			if dev.Title == a.source || a.source == "" {
				a.dev = dev
				break
			}
		}
	}

	if a.dev == nil {
		return errors.New("No audio source found")
	}
	log.Log(logger.Debug, "Found audio source", "source", a.dev.Title)

	// ToDo: time out if Open takes too long.
	err = a.dev.Open()
	if err != nil {
		return err
	}
	log.Log(logger.Debug, "Opened audio source")

	// 2 channels is what most devices need to record in. If mono is requested,
	// the recording will be converted in formatBuffer().
	_, err = a.dev.NegotiateChannels(2)
	if err != nil {
		return err
	}

	// Try to negotiate a rate to record in that is divisible by the wanted rate
	// so that it can be easily downsampled to the wanted rate.
	// Note: if a card thinks it can record at a rate but can't actually, this can cause a failure. Eg.
	// the audioinjector is supposed to record at 8000Hz and 16000Hz but it can't due to a firmware issue,
	// to fix this 8000 and 16000 must be removed from the Rates slice.
	foundRate := false
	for i := 0; i < len(Rates) && !foundRate; i++ {
		if Rates[i] < a.SampleRate {
			continue
		}
		if Rates[i]%a.SampleRate == 0 {
			_, err = a.dev.NegotiateRate(Rates[i])
			if err == nil {
				foundRate = true
				log.Log(logger.Debug, "Sample rate set", "rate", Rates[i])
			}
		}
	}

	// If no easily divisible rate is found, then use the default rate.
	if !foundRate {
		log.Log(logger.Warning, "Unable to sample at requested rate, default used.", "rateRequested", a.SampleRate)
		_, err = a.dev.NegotiateRate(defaultSampleRate)
		if err != nil {
			return err
		}
		log.Log(logger.Debug, "Sample rate set", "rate", defaultSampleRate)
	}

	var aFmt alsa.FormatType
	switch a.BitDepth {
	case 16:
		aFmt = alsa.S16_LE
	case 32:
		aFmt = alsa.S32_LE
	default:
		return fmt.Errorf("unsupported sample bits %v", a.BitDepth)
	}
	_, err = a.dev.NegotiateFormat(aFmt)
	if err != nil {
		return err
	}

	// Either 8192 or 16384 bytes is a reasonable ALSA buffer size.
	_, err = a.dev.NegotiateBufferSize(8192, 16384)
	if err != nil {
		return err
	}

	if err = a.dev.Prepare(); err != nil {
		return err
	}
	log.Log(logger.Debug, "Successfully negotiated ALSA params")
	return nil
}

// input continously records audio and writes it to the ringbuffer.
// Re-opens the device and tries again if ASLA returns an error.
func (a *AudioDevice) input() {
	for {
		a.mu.Lock()
		fmt.Println("input lock")
		if a.dev == nil {
			fmt.Println("INPUT:", "dev: NIL", a.mode)
		} else {
			fmt.Println("INPUT:", "dev: VALID", a.mode)
		}
		if a.rb == nil {
			fmt.Println("INPUT:", "rb: NIL", a.mode)
		} else {
			fmt.Println("INPUT:", "rb: VALID", a.mode)
		}
		switch a.mode {
		case paused:
			a.mu.Unlock()
			fmt.Println("input unlock")
			time.Sleep(time.Duration(a.RecPeriod) * time.Second)
			continue
		case stopped:
			a.mu.Unlock()
			fmt.Println("input unlock")
			return
		}
		log.Log(logger.Debug, "Recording audio for period", "seconds", a.RecPeriod)
		fmt.Println("LEN:", len(a.ab.Data))
		err := a.dev.Read(a.ab.Data)
		fmt.Println("input read")
		if err != nil {
			log.Log(logger.Debug, "Device.Read failed", "error", err.Error())
			err = a.open() // re-open
			if err != nil {
				a.mu.Unlock()
				fmt.Println("input unlock")
				log.Log(logger.Fatal, "alsa.open failed", "error", err.Error())
			}
			a.mu.Unlock()
			fmt.Println("input unlock")
			continue
		}

		toWrite := a.formatBuffer()
		fmt.Println("input point")

		log.Log(logger.Debug, "Audio format conversion has been performed where needed")

		var n int
		n, err = a.rb.Write(toWrite.Data)
		fmt.Println("input write")
		switch err {
		case nil:
			log.Log(logger.Debug, "Wrote audio to ringbuffer", "length", n)
		case ring.ErrDropped:
			log.Log(logger.Warning, "Dropped audio")
		default:
			a.mu.Unlock()
			fmt.Println("input unlock")
			log.Log(logger.Error, "Unexpected ringbuffer error", "error", err.Error())
			return
		}
		a.mu.Unlock()
		fmt.Println("input unlock")
	}
}

// Read reads a full PCM chunk from the ringbuffer, returning the number of bytes read upon success.
// Any errors returned are unexpected and should be considered fatal.
func (a *AudioDevice) Read(p []byte) (n int, err error) {
	fmt.Println("read lock")
	a.mu.Lock()
	switch a.mode {
	case paused:
		return 0, nil
	case stopped:
		return 0, nil
	}
	if a.rb == nil {
		fmt.Println("READ:", "NIL", a.mode)
	} else {
		fmt.Println("READ:", "VALID", a.mode)
	}
	chunk, err := a.rb.Next(rbNextTimeout)
	switch err {
	case nil:
		// Do nothing.
	case ring.ErrTimeout:
		return 0, nil
	case io.EOF:
		log.Log(logger.Error, "Unexpected EOF from ring.Next")
		return 0, io.ErrUnexpectedEOF
	default:
		log.Log(logger.Error, "Unexpected error from ring.Next", "error", err.Error())
		return 0, err
	}
	n, err = io.ReadFull(a.rb, p[:chunk.Len()])
	if err != nil {
		log.Log(logger.Error, "Unexpected error from ring.Read", "error", err.Error())
		return n, err
	}
	log.Log(logger.Debug, "Read audio from ringbuffer", "length", n)
	a.mu.Unlock()
	fmt.Println("read unlock")
	return n, nil
}

// formatBuffer returns an ALSA buffer that has the recording data from the ac's original ALSA buffer but stored
// in the desired format specified by the ac's parameters.
func (a *AudioDevice) formatBuffer() alsa.Buffer {
	var err error
	wantChannels := a.Channels
	wantRate := a.SampleRate

	// If nothing needs to be changed, return the original.
	if a.ab.Format.Channels == wantChannels && a.ab.Format.Rate == wantRate {
		return a.ab
	}

	formatted := alsa.Buffer{Format: a.ab.Format}
	bufCopied := false
	if a.ab.Format.Channels != wantChannels {

		// Convert channels.
		if a.ab.Format.Channels == 2 && wantChannels == 1 {
			if formatted.Data, err = pcm.StereoToMono(a.ab); err != nil {
				log.Log(logger.Warning, "Channel conversion failed, audio has remained stereo", "error", err.Error())
			} else {
				formatted.Format.Channels = 1
			}
			bufCopied = true
		}
	}

	if a.ab.Format.Rate != wantRate {

		// Convert rate.
		if bufCopied {
			formatted.Data, err = pcm.Resample(formatted, wantRate)
		} else {
			formatted.Data, err = pcm.Resample(a.ab, wantRate)
		}
		if err != nil {
			log.Log(logger.Warning, "Rate conversion failed, audio has remained original rate", "error", err.Error())
		} else {
			formatted.Format.Rate = wantRate
		}
	}
	return formatted
}