package logger

import (
	log "github.com/sirupsen/logrus"
	"github.com/stretchr/testify/assert"
	"io"
	"os"
	"testing"

	"git.urec56.ru/urec/chat_back_go/config"
)

func Test_NewLogger(t *testing.T) {
	testTable := []struct {
		name              string
		mode              string
		expectedFormatter log.Formatter
		expectedOut       io.Writer
		expectedLevel     log.Level
	}{
		{
			name:              "prod",
			mode:              "PROD",
			expectedFormatter: &log.JSONFormatter{},
			expectedOut:       os.Stdout,
			expectedLevel:     log.WarnLevel,
		},
		{
			name:              "stage",
			mode:              "STAGE",
			expectedFormatter: &log.TextFormatter{},
			expectedOut:       os.Stdout,
			expectedLevel:     log.InfoLevel,
		},
		{
			name:              "dev",
			mode:              "DEV",
			expectedFormatter: &log.TextFormatter{},
			expectedOut:       os.Stdout,
			expectedLevel:     log.DebugLevel,
		},
		{
			name:              "test",
			mode:              "TEST",
			expectedFormatter: &log.TextFormatter{},
			expectedOut:       os.Stdout,
			expectedLevel:     log.DebugLevel,
		},
	}

	for _, tc := range testTable {
		t.Run(tc.name, func(t *testing.T) {

			logger := NewLogger(config.Config{Mode: tc.mode})
			assert.Equal(t, tc.expectedFormatter, logger.Formatter)
			assert.Equal(t, tc.expectedOut, logger.Out)
			assert.Equal(t, tc.expectedLevel, logger.Level)
		})
	}
}

func Test_configureLogger(t *testing.T) {
	testTable := []struct {
		name              string
		mode              string
		expectedFormatter log.Formatter
		expectedOut       io.Writer
		expectedLevel     log.Level
		exitCalled        bool
	}{
		{
			name:              "prod",
			mode:              "PROD",
			expectedFormatter: &log.JSONFormatter{},
			expectedOut:       os.Stdout,
			expectedLevel:     log.WarnLevel,
		},
		{
			name:              "stage",
			mode:              "STAGE",
			expectedFormatter: &log.TextFormatter{},
			expectedOut:       os.Stdout,
			expectedLevel:     log.InfoLevel,
		},
		{
			name:              "dev",
			mode:              "DEV",
			expectedFormatter: &log.TextFormatter{},
			expectedOut:       os.Stdout,
			expectedLevel:     log.DebugLevel,
		},
		{
			name:              "test",
			mode:              "TEST",
			expectedFormatter: &log.TextFormatter{},
			expectedOut:       os.Stdout,
			expectedLevel:     log.DebugLevel,
		},
		{
			name:              "incorrect_mode",
			expectedFormatter: &log.TextFormatter{},
			expectedOut:       os.Stderr,
			expectedLevel:     log.InfoLevel,
			exitCalled:        true,
		},
	}

	for _, tc := range testTable {
		t.Run(tc.name, func(t *testing.T) {
			logger := &Logger{Logger: log.New()}
			exitCalled := false

			logger.ExitFunc = func(i int) {
				exitCalled = true
			}

			configureLogger(config.Config{Mode: tc.mode}, logger)

			assert.EqualExportedValues(t, tc.expectedFormatter, logger.Formatter)
			assert.EqualExportedValues(t, tc.expectedOut, logger.Out)
			assert.EqualExportedValues(t, tc.expectedLevel, logger.Level)
			assert.Equal(t, tc.exitCalled, exitCalled)
		})
	}
}