package v2

import (
	"testing"

	"github.com/stretchr/testify/assert"

	v1 "edge-infra.dev/pkg/sds/display/k8s/apis/v1"
)

func TestValidateDisplayPorts(t *testing.T) {
	tcs := []struct {
		displayConfig *DisplayConfig
		valid         bool
	}{
		// test case 1: no displays configured
		{
			displayConfig: &DisplayConfig{Displays: Displays{}},
			valid:         true,
		},
		// test case 2: single display port configured
		{
			displayConfig: &DisplayConfig{Displays: Displays{
				{DisplayPort: NewDisplayPort("card0", "DP1")},
			}},
			valid: true,
		},
		// test case 3: multiple display ports configured
		{
			displayConfig: &DisplayConfig{Displays: Displays{
				{DisplayPort: NewDisplayPort("card0", "DP1")},
				{DisplayPort: NewDisplayPort("card1", "DP2")},
			}},
			valid: true,
		},
		// test case 4: identical displays ports configured
		{
			displayConfig: &DisplayConfig{Displays: Displays{
				{DisplayPort: NewDisplayPort("card0", "DP1")},
				{DisplayPort: NewDisplayPort("card0", "DP1")},
			}},
			valid: false,
		},
	}
	for idx, tc := range tcs {
		err := tc.displayConfig.Validate()
		if tc.valid {
			assert.NoError(t, err, "test case %d failed: display config should be valid", idx+1)
			continue
		}
		assert.Error(t, err, "test case %d failed: display config should be invalid", idx+1)
	}
}

func TestValidateNonSettableFields(t *testing.T) {
	mpid := MPID("1234")
	tcs := []struct {
		displayConfig *DisplayConfig
		valid         bool
	}{
		// test case 1: MPID is set in display config spec
		{
			displayConfig: &DisplayConfig{Displays: Displays{
				{MPID: nil, SupportedResolutions: []Resolution{}},
			}},
			valid: false,
		},
		// test case 2: supported resolutions is set in display config spec
		{
			displayConfig: &DisplayConfig{Displays: Displays{
				{MPID: &mpid, SupportedResolutions: nil},
			}},
			valid: false,
		},
		// test case 3: MPID / supported resolutions are not set in display spec
		{
			displayConfig: &DisplayConfig{Displays: Displays{
				{MPID: nil, SupportedResolutions: nil},
			}},
			valid: true,
		},
	}
	for idx, tc := range tcs {
		err := tc.displayConfig.Validate()
		if tc.valid {
			assert.NoError(t, err, "test case %d failed: display config should be valid", idx+1)
			continue
		}
		assert.Error(t, err, "test case %d failed: display config should be invalid", idx+1)
	}
}

func TestValidateV1(t *testing.T) {
	tcs := []struct {
		displayConfig *DisplayConfig
		valid         bool
	}{
		// test case 1: v1 display configuration is not configured
		{
			displayConfig: &DisplayConfig{V1: nil},
			valid:         true,
		},
		// test case 2: v2 displays and v1 display configuration configured
		{
			displayConfig: &DisplayConfig{Displays: Displays{
				{Primary: &primary, DisplayPort: NewDisplayPort("card0", "DP1")},
			},
				V1: &v1.DisplayConfig{}},
			valid: false,
		},
		// test case 3: v2 layouts and v1 display configuration configured
		{
			displayConfig: &DisplayConfig{
				Layout: Layout{NewDisplayPort("card0", "DP1")},
				V1:     &v1.DisplayConfig{},
			},
			valid: false,
		},
		// test case 4: v2 DPMS and v1 display configuration configured
		{
			displayConfig: &DisplayConfig{
				DPMS: &DPMS{
					StandbyTime: &thirtySeconds,
					SuspendTime: &sixtySeconds,
					OffTime:     &ninetySeconds,
				},
				V1: &v1.DisplayConfig{}},
			valid: false,
		},
		// test case 5: v1 display configuration configured
		{
			displayConfig: &DisplayConfig{
				V1: &v1.DisplayConfig{},
			},
			valid: true,
		},
	}
	for idx, tc := range tcs {
		err := tc.displayConfig.Validate()
		if tc.valid {
			assert.NoError(t, err, "test case %d failed: display config should be valid", idx+1)
			continue
		}
		assert.Error(t, err, "test case %d failed: display config should be invalid", idx+1)
	}
}

func TestValidatePrimary(t *testing.T) {
	tcs := []struct {
		displayConfig *DisplayConfig
		valid         bool
	}{
		// test case 1: no primary dislay configured
		{
			displayConfig: &DisplayConfig{
				Displays: Displays{
					{DisplayPort: NewDisplayPort("card0", "DP1")},
					{DisplayPort: NewDisplayPort("card1", "DP2")},
				},
			},
			valid: true,
		},
		// test case 2: single primary display configured
		{
			displayConfig: &DisplayConfig{
				Displays: Displays{
					{Primary: &primary, DisplayPort: NewDisplayPort("card0", "DP1")},
				},
			},
			valid: true,
		},
		// test case 3: multiple primary displays configured
		{
			displayConfig: &DisplayConfig{Displays: Displays{
				{Primary: &primary, DisplayPort: NewDisplayPort("card0", "DP1")},
				{Primary: &primary, DisplayPort: NewDisplayPort("card1", "DP2")},
			}},
			valid: false,
		},
	}
	for idx, tc := range tcs {
		err := tc.displayConfig.Validate()
		if tc.valid {
			assert.NoError(t, err, "test case %d failed: display config should be valid", idx+1)
			continue
		}
		assert.Error(t, err, "test case %d failed: display config should be invalid", idx+1)
	}
}

func TestValidateDMPS(t *testing.T) {
	tcs := []struct {
		displayConfig *DisplayConfig
		valid         bool
	}{
		// test case 1: DPMS is not configured
		{
			displayConfig: &DisplayConfig{DPMS: nil},
			valid:         true,
		},
		// test case 2: standby time greater than suspendTime
		{
			displayConfig: &DisplayConfig{DPMS: &DPMS{
				StandbyTime: &sixtySeconds,
				SuspendTime: &thirtySeconds,
			}},
			valid: false,
		},
		// test case 3: suspendTime greater than offTime
		{
			displayConfig: &DisplayConfig{DPMS: &DPMS{
				SuspendTime: &sixtySeconds,
				OffTime:     &thirtySeconds,
			}},
			valid: false,
		},
		// test case 4: valid DPMS configuration
		{
			displayConfig: &DisplayConfig{DPMS: &DPMS{
				StandbyTime: &thirtySeconds,
				SuspendTime: &sixtySeconds,
				OffTime:     &ninetySeconds,
			}},
			valid: true,
		},
	}
	for idx, tc := range tcs {
		err := tc.displayConfig.Validate()
		if tc.valid {
			assert.NoError(t, err, "test case %d failed: display config should be valid", idx+1)
			continue
		}
		assert.Error(t, err, "test case %d failed: display config should be invalid", idx+1)
	}
}