package media_test

import (
	"context"
	"database/sql"
	"errors"
	"io"
	"testing"
	"time"

	"git.netflux.io/rob/clipper/config"
	"git.netflux.io/rob/clipper/generated/mocks"
	"git.netflux.io/rob/clipper/generated/store"
	"git.netflux.io/rob/clipper/media"
	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
	"github.com/stretchr/testify/require"
	"go.uber.org/zap"
)

func TestGetPeaksFromFileStore(t *testing.T) {
	const inFixturePath = "testdata/tone-44100-stereo-int16-30000ms.raw"

	ctx := context.Background()
	logger := zap.NewNop().Sugar()
	mediaSetID := uuid.New()
	mediaSet := store.MediaSet{
		ID:                       mediaSetID,
		AudioChannels:            2,
		AudioFrames:              sql.NullInt64{Int64: 1_323_000, Valid: true},
		AudioRawS3Key:            sql.NullString{String: "raw audio key", Valid: true},
		AudioRawS3UploadedAt:     sql.NullTime{Time: time.Now(), Valid: true},
		AudioEncodedS3Key:        sql.NullString{String: "encoded audio key", Valid: true},
		AudioEncodedS3UploadedAt: sql.NullTime{Time: time.Now(), Valid: true},
	}

	t.Run("NOK,ErrorFetchingMediaSet", func(t *testing.T) {
		var mockStore mocks.Store
		mockStore.On("GetMediaSet", mock.Anything, mediaSetID).Return(store.MediaSet{}, errors.New("db went boom"))
		service := media.NewMediaSetService(&mockStore, nil, nil, nil, config.Config{}, logger)
		_, err := service.GetPeaks(ctx, mediaSetID, 10)
		assert.EqualError(t, err, "error getting media set: db went boom")
	})

	t.Run("NOK,ErrorGettingObjectFromFileStore", func(t *testing.T) {
		var mockStore mocks.Store
		mockStore.On("GetMediaSet", mock.Anything, mediaSetID).Return(mediaSet, nil)
		defer mockStore.AssertExpectations(t)

		var fileStore mocks.FileStore
		fileStore.On("GetObject", mock.Anything, "raw audio key").Return(nil, errors.New("boom"))

		service := media.NewMediaSetService(&mockStore, nil, &fileStore, nil, config.Config{}, logger)
		_, err := service.GetPeaks(ctx, mediaSetID, 10)
		require.EqualError(t, err, "error getting object from file store: boom")
	})

	t.Run("NOK,ErrorGettingObjectURL", func(t *testing.T) {
		var mockStore mocks.Store
		mockStore.On("GetMediaSet", mock.Anything, mediaSetID).Return(mediaSet, nil)
		defer mockStore.AssertExpectations(t)

		var fileStore mocks.FileStore
		reader := fixtureReader(t, inFixturePath, 5_292_000)
		fileStore.On("GetObject", mock.Anything, "raw audio key").Return(reader, nil)
		fileStore.On("GetURL", mock.Anything, "encoded audio key").Return("", errors.New("network error"))
		defer fileStore.AssertExpectations(t)

		service := media.NewMediaSetService(&mockStore, nil, &fileStore, nil, config.Config{}, logger)
		stream, err := service.GetPeaks(ctx, mediaSetID, 10)
		require.NoError(t, err)

		var hadError bool
		for {
			_, err := stream.Next()
			if err != nil {
				hadError = true
				assert.EqualError(t, err, "error waiting for progress: error generating object URL: network error")
				break
			}
		}
		assert.True(t, hadError)
	})

	t.Run("OK", func(t *testing.T) {
		var mockStore mocks.Store
		mockStore.On("GetMediaSet", mock.Anything, mediaSetID).Return(mediaSet, nil)
		defer mockStore.AssertExpectations(t)

		var fileStore mocks.FileStore
		reader := fixtureReader(t, inFixturePath, 5_292_000)
		fileStore.On("GetObject", mock.Anything, "raw audio key").Return(reader, nil)
		fileStore.On("GetURL", mock.Anything, "encoded audio key").Return("https://www.example.com/foo", nil)
		defer fileStore.AssertExpectations(t)

		numBins := 10
		service := media.NewMediaSetService(&mockStore, nil, &fileStore, nil, config.Config{}, logger)
		stream, err := service.GetPeaks(ctx, mediaSetID, numBins)
		require.NoError(t, err)

		lastPeaks := make([]int16, 2) // stereo
		var (
			count               int
			lastPercentComplete float32
			lastURL             string
		)

		for {
			progress, err := stream.Next()
			if err != io.EOF {
				require.NoError(t, err)
			}

			assert.Len(t, progress.Peaks, 2)
			assert.GreaterOrEqual(t, progress.PercentComplete, lastPercentComplete)
			lastPercentComplete = progress.PercentComplete
			lastURL = progress.URL

			if err == io.EOF {
				break
			}

			// the fixture is a tone gradually increasing in amplitude:
			assert.Greater(t, progress.Peaks[0], lastPeaks[0])
			assert.Greater(t, progress.Peaks[1], lastPeaks[1])
			lastPeaks = progress.Peaks
			count++
		}

		assert.Equal(t, float32(100), lastPercentComplete)
		assert.Equal(t, []int16{32_767, 32_766}, lastPeaks)
		assert.Equal(t, numBins, count)
		assert.Equal(t, "https://www.example.com/foo", lastURL)
	})
}