// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package main

import (
	"context"
	"encoding/base64"
	"flag"
	"fmt"
	"math/rand"
	"os"
	"path"
	"reflect"
	"strings"
	"testing"
	"time"

	fg "go.fuchsia.dev/fuchsia/tools/femu-control/femu-grpc"
)

type keyEvent struct {
	evType string
	keySeq []string
}

type fakeFemuGrpcClient struct {
	keyEvents []keyEvent
}

func (f *fakeFemuGrpcClient) StreamScreen(opts fg.StreamScreenOpts) (fg.Frames, error) {
	numFrames := opts.NumFrames
	if numFrames == 0 || numFrames > 10 {
		numFrames = 10
	}

	frames := fg.Frames{}
	frames.Width = 1
	frames.Height = 1

	const png1x1Base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQYV2PwUSn4DwADgAHgUix5GgAAAABJRU5ErkJggg=="
	pngBytes, _ := base64.StdEncoding.DecodeString(png1x1Base64)
	for i := uint(0); i < numFrames; i++ {
		frames.Images = append(frames.Images, pngBytes)
	}

	return frames, nil
}

func (f *fakeFemuGrpcClient) StreamAudio(opts fg.StreamAudioOpts) (fg.AudioPayload, error) {
	audio := fg.AudioPayload{}

	byteSize := uint(opts.Duration.Milliseconds()) * opts.Format.SamplingRate / 1000 * opts.Format.BitsPerSample / 8
	if opts.Format.Channels == "STEREO" {
		byteSize = byteSize * 2
	}

	audio.Bytes = make([]byte, byteSize)
	audio.LengthMs = uint(opts.Duration.Milliseconds())
	return audio, nil
}

func (f *fakeFemuGrpcClient) KeyDown(seq []string) error {
	f.keyEvents = append(f.keyEvents, keyEvent{
		evType: "DOWN",
		keySeq: seq,
	})
	return nil
}

func (f *fakeFemuGrpcClient) KeyUp(seq []string) error {
	f.keyEvents = append(f.keyEvents, keyEvent{
		evType: "UP",
		keySeq: seq,
	})
	return nil
}

func (f *fakeFemuGrpcClient) KeyPress(seq []string) error {
	f.keyEvents = append(f.keyEvents, keyEvent{
		evType: "PRESS",
		keySeq: seq,
	})
	return nil
}

func TestStreamScreen(t *testing.T) {
	client := fakeFemuGrpcClient{}
	ctx := context.WithValue(context.Background(), "client", &client)

	var seededRand *rand.Rand = rand.New(
		rand.NewSource(time.Now().UnixNano()))
	tmpDir := fmt.Sprintf("/tmp/femu%v", seededRand.Int())

	testCases := []struct {
		name           string
		flags          string
		expectedStatus string
		expectedError  string
		setup          func()
		cleanup        func()
	}{
		{
			name:           "num-frames and duration both missing",
			flags:          fmt.Sprintf("-out %v/screen%%.png", tmpDir),
			expectedStatus: "usage error",
			expectedError:  "-num-frames and -duration cannot be both zero",
		},
		{
			name:           "path is not directory",
			flags:          fmt.Sprintf("-duration 1s -out %v/file/screen%%.png", tmpDir),
			expectedStatus: "usage error",
			expectedError:  fmt.Sprintf("path %v/file/ invalid: stat %v/file/: not a directory", tmpDir, tmpDir),
			setup: func() {
				os.MkdirAll(tmpDir, 0755)
				os.Create(path.Join(tmpDir, "file"))
			},
			cleanup: func() {
				os.Remove(path.Join(tmpDir, "file"))
			},
		},
		{
			name:           "filename not containing extension",
			flags:          fmt.Sprintf("-duration 1s -out %v/screen%%", tmpDir),
			expectedStatus: "usage error",
			expectedError:  "filename 'screen%' doesn't contain any extension!",
		},
		{
			name:           "filename not containing %",
			flags:          fmt.Sprintf("-duration 1s -out %v/screen.jpg", tmpDir),
			expectedStatus: "success",
		},
		{
			name:           "unsupported extension",
			flags:          fmt.Sprintf("-duration 1s -out %v/screen%%.wav", tmpDir),
			expectedStatus: "usage error",
			expectedError:  "filename 'screen%.wav' has unsupported extension: .wav. supported extensions are jpeg, jpg, gif, and png.",
		},
		{
			name:           "valid usage: jpg",
			flags:          fmt.Sprintf("-duration 1s -out %v/screen%%.jpg", tmpDir),
			expectedStatus: "success",
			cleanup:        func() { os.RemoveAll(tmpDir) },
		},
		{
			name:           "valid usage: png",
			flags:          fmt.Sprintf("-duration 1s -out %v/screen%%.png", tmpDir),
			expectedStatus: "success",
			cleanup:        func() { os.RemoveAll(tmpDir) },
		},
		{
			name:           "valid usage: gif",
			flags:          fmt.Sprintf("-duration 1s -out %v/screen.gif", tmpDir),
			expectedStatus: "success",
			cleanup:        func() { os.RemoveAll(tmpDir) },
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			if tc.setup != nil {
				tc.setup()
			}
			if tc.cleanup != nil {
				defer tc.cleanup()
			}

			cmd := recordScreenCmd{}

			f := flag.NewFlagSet("", flag.ContinueOnError)
			cmd.SetFlags(f)

			err := f.Parse(strings.Split(tc.flags, " "))
			if err != nil {
				t.Errorf("parse flags failed: %v", err)
				return
			}

			err = cmd.ValidateArgs()
			switch {
			case err == nil && tc.expectedStatus == "usage error":
				t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
			case err != nil && tc.expectedStatus == "usage error" && tc.expectedError != err.Error():
				t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
				return
			case err != nil && tc.expectedStatus != "usage error":
				t.Errorf("expected: %v actual (usage error): %v", tc.expectedStatus, err)
				return
			case err != nil:
				return
			}

			err = cmd.run(ctx)
			if tc.expectedStatus == "failure" {
				if err == nil || err.Error() != tc.expectedError {
					t.Errorf("expected: %v actual: %v", tc.expectedError, err)
				}
			}

			if tc.expectedStatus == "success" {
				if err != nil {
					t.Errorf("expected: success actual: %v", err)
				}
			}
		})
	}
}

func TestStreamAudio(t *testing.T) {
	client := fakeFemuGrpcClient{}
	ctx := context.WithValue(context.Background(), "client", &client)

	var seededRand *rand.Rand = rand.New(
		rand.NewSource(time.Now().UnixNano()))
	tmpDir := fmt.Sprintf("/tmp/femu%v", seededRand.Int())

	testCases := []struct {
		name           string
		flags          string
		expectedStatus string
		expectedError  string
		setup          func()
		cleanup        func()
	}{
		{
			name:           "-duration missing",
			flags:          fmt.Sprintf("-out %v/audio.wav", tmpDir),
			expectedStatus: "usage error",
			expectedError:  "-duration cannot be zero",
		},
		{
			name:           "path is not directory",
			flags:          fmt.Sprintf("-duration 1s -out %v/file/audio.wav", tmpDir),
			expectedStatus: "usage error",
			expectedError:  fmt.Sprintf("path %v/file/ invalid: stat %v/file/: not a directory", tmpDir, tmpDir),
			setup: func() {
				os.MkdirAll(tmpDir, 0755)
				os.Create(path.Join(tmpDir, "file"))
			},
			cleanup: func() {
				os.Remove(path.Join(tmpDir, "file"))
			},
		},
		{
			name:           "invalid args: channels",
			flags:          fmt.Sprintf("-duration 1s -out %v/audio.wav -channels SURROUND", tmpDir),
			expectedStatus: "usage error",
			expectedError:  "unsupported channel format: SURROUND",
		},
		{
			name:           "invalid args: bit depth",
			flags:          fmt.Sprintf("-duration 1s -out %v/audio.wav -bit-depth 32", tmpDir),
			expectedStatus: "usage error",
			expectedError:  "unsupported number of bits per sample: 32",
		},
		{
			name:           "invalid args: sampling rate",
			flags:          fmt.Sprintf("-duration 1s -out %v/audio.wav -sampling-rate 0", tmpDir),
			expectedStatus: "usage error",
			expectedError:  "invalid sampling rate: 0",
		},
		{
			name:           "valid usage",
			flags:          fmt.Sprintf("-duration 1s -out %v/screen.wav", tmpDir),
			expectedStatus: "success",
			cleanup:        func() { os.RemoveAll(tmpDir) },
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			if tc.setup != nil {
				tc.setup()
			}
			if tc.cleanup != nil {
				defer tc.cleanup()
			}

			cmd := recordAudioCmd{}

			f := flag.NewFlagSet("", flag.ContinueOnError)
			cmd.SetFlags(f)

			err := f.Parse(strings.Split(tc.flags, " "))
			if err != nil {
				t.Errorf("parse flags failed: %v", err)
				return
			}

			err = cmd.ValidateArgs()
			switch {
			case err == nil && tc.expectedStatus == "usage error":
				t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
			case err != nil && tc.expectedStatus == "usage error" && tc.expectedError != err.Error():
				t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
				return
			case err != nil && tc.expectedStatus != "usage error":
				t.Errorf("expected: %v actual (usage error): %v", tc.expectedStatus, err)
				return
			case err != nil:
				return
			}

			err = cmd.run(ctx)
			if tc.expectedStatus == "failure" {
				if err == nil || err.Error() != tc.expectedError {
					t.Errorf("expected: %v actual: %v", tc.expectedError, err)
				}
			}

			if tc.expectedStatus == "success" {
				if err != nil {
					t.Errorf("expected: success actual: %v", err)
				}
			}
		})
	}
}

func TestKeyboard(t *testing.T) {
	client := fakeFemuGrpcClient{}
	ctx := context.WithValue(context.Background(), "client", &client)

	testCases := []struct {
		name           string
		flags          string
		expectedStatus string
		expectedError  string
		setup          func()
		cleanup        func()
	}{
		{
			name:           "invalid type",
			flags:          "-event OTHER Ctrl+Alt+A",
			expectedStatus: "usage error",
			expectedError:  "unknown event type: OTHER",
		},
		{
			name:           "key sequence missing",
			flags:          "-event PRESS",
			expectedStatus: "usage error",
			expectedError:  "key sequence missing",
		},
		{
			name:           "key down",
			flags:          "-event DOWN Control+Alt+A",
			expectedStatus: "success",
			expectedError:  "",
			cleanup: func() {
				if len(client.keyEvents) == 0 {
					t.Fatalf("client.keyEvents is empty")
				}
				event := client.keyEvents[len(client.keyEvents)-1]
				if event.evType != "DOWN" {
					t.Errorf("incorrect event.evType: expected: %v actual: %v", "DOWN", event.evType)
				}

				expectedKeySeq := []string{"Control", "Alt", "A"}
				if !reflect.DeepEqual(event.keySeq, expectedKeySeq) {
					t.Errorf("incorrect event.keySeq: expected: %v actual: %v", expectedKeySeq, event.keySeq)
				}
			},
		},
		{
			name:           "key up",
			flags:          "-event UP Alt+Shift+3",
			expectedStatus: "success",
			expectedError:  "",
			cleanup: func() {
				if len(client.keyEvents) == 0 {
					t.Fatalf("client.keyEvents is empty")
				}
				event := client.keyEvents[len(client.keyEvents)-1]
				if event.evType != "UP" {
					t.Errorf("incorrect event.evType: expected: %v actual: %v", "UP", event.evType)
				}

				expectedKeySeq := []string{"Alt", "Shift", "3"}
				if !reflect.DeepEqual(event.keySeq, expectedKeySeq) {
					t.Errorf("incorrect event.keySeq: expected: %v actual: %v", expectedKeySeq, event.keySeq)
				}
			},
		},
		{
			name:           "key press",
			flags:          "-event PRESS Meta+Z",
			expectedStatus: "success",
			expectedError:  "",
			cleanup: func() {
				if len(client.keyEvents) == 0 {
					t.Fatalf("client.keyEvents is empty")
				}
				event := client.keyEvents[len(client.keyEvents)-1]
				if event.evType != "PRESS" {
					t.Errorf("incorrect event.evType: expected: %v actual: %v", "PRESS", event.evType)
				}

				expectedKeySeq := []string{"Meta", "Z"}
				if !reflect.DeepEqual(event.keySeq, expectedKeySeq) {
					t.Errorf("incorrect event.keySeq: expected: %v actual: %v", expectedKeySeq, event.keySeq)
				}
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			if tc.setup != nil {
				tc.setup()
			}
			if tc.cleanup != nil {
				defer tc.cleanup()
			}

			cmd := keyboardCmd{}

			f := flag.NewFlagSet("", flag.ContinueOnError)
			cmd.SetFlags(f)

			err := f.Parse(strings.Split(tc.flags, " "))
			if err != nil {
				t.Errorf("parse flags failed: %v", err)
				return
			}
			if f.Arg(0) != "" {
				cmd.keySequence = strings.Split(f.Arg(0), "+")
			}

			err = cmd.ValidateArgs()
			switch {
			case err == nil && tc.expectedStatus == "usage error":
				t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
			case err != nil && tc.expectedStatus == "usage error" && tc.expectedError != err.Error():
				t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
				return
			case err != nil && tc.expectedStatus != "usage error":
				t.Errorf("expected: %v actual (usage error): %v", tc.expectedStatus, err)
				return
			case err != nil:
				return
			}

			err = cmd.run(ctx)
			if tc.expectedStatus == "failure" {
				if err == nil || err.Error() != tc.expectedError {
					t.Errorf("expected: %v actual: %v", tc.expectedError, err)
				}
			}

			if tc.expectedStatus == "success" {
				if err != nil {
					t.Errorf("expected: success actual: %v", err)
				}
			}
		})
	}
}