package util

import (
	"fmt"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
)

func TestConvertParseLocalUnix(t *testing.T) {
	type args struct {
		unix int64
	}

	tests := []struct {
		Name string
		Args args
	}{
		{
			Name: "08:00:00",
			Args: args{
				unix: 1727049600,
			},
		},
		{
			Name: "09:00:00",
			Args: args{
				unix: 1727053200,
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.Name, func(t *testing.T) {
			got, err := ConvertParseLocalUnix(tt.Name)
			assert.Nil(t, err)
			assert.Equal(t, tt.Args.unix, got)
		})
	}
}

func TestGetLastDayOfMonth(t *testing.T) {
	tests := []struct {
		month string
		got   string
	}{
		{
			month: "2022-02",
			got:   "2022-02-28",
		},
		{
			month: "2023-02",
			got:   "2023-02-28",
		},
		{
			month: "2024-02",
			got:   "2024-02-29",
		},
		{
			month: "2024-10",
			got:   "2024-10-31",
		}, {
			month: "2024-09",
			got:   "2024-09-30",
		},
	}

	for _, tt := range tests {
		t.Run(tt.month, func(t *testing.T) {
			got, err := GetLastDayOfMonth(tt.month)
			assert.Nil(t, err)
			assert.Equal(t, tt.got, got)
		})
	}
}

func TestGetMonthsInRange(t *testing.T) {
	tests := []struct {
		startMonth string
		endMonth   string
		got        []string
	}{
		{
			startMonth: "2023-01",
			endMonth:   "2023-03",
			got: []string{
				"2023-01",
				"2023-02",
				"2023-03",
			},
		},
		{
			startMonth: "2023-01",
			endMonth:   "2023-12",
			got: []string{
				"2023-01",
				"2023-02",
				"2023-03",
				"2023-04",
				"2023-05",
				"2023-06",
				"2023-07",
				"2023-08",
				"2023-09",
				"2023-10",
				"2023-11",
				"2023-12",
			},
		},
		{
			startMonth: "2023-01",
			endMonth:   "2023-01",
			got: []string{
				"2023-01",
			},
		},
		{
			startMonth: "2023-01",
			endMonth:   "2023-01",
			got: []string{
				"2023-01",
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.startMonth, func(t *testing.T) {
			got, err := GetMonthsInRange(tt.startMonth, tt.endMonth)
			assert.Nil(t, err)
			assert.Equal(t, tt.got, got)
		})
	}
}

func TestRoundToTwoDecimals(t *testing.T) {
	tests := []struct {
		exp float64
		got float64
	}{
		{
			exp: 123.456,
			got: 123.46,
		},
		{
			exp: 123.455,
			got: 123.46,
		},
		{
			exp: 123.444,
			got: 123.44,
		},
		{
			exp: 123.4551,
			got: 123.46,
		},
		{
			exp: 123.4449,
			got: 123.44,
		},
		{
			exp: 0,
			got: 0,
		},
		{
			exp: 0.2,
			got: 0.2,
		},
	}

	for _, tt := range tests {
		t.Run("TestRoundToTwoDecimals", func(t *testing.T) {
			got := RoundToTwoDecimals(tt.exp)
			assert.Equal(t, tt.got, got)
		})
	}
}

func TestGet21DayPeriods(t *testing.T) {
	tests := []struct {
		startDay string
		endDay   string
		got      struct {
			DateRange       [][]string
			Day             int32
			MiddleDayString []string
		}
	}{
		{
			startDay: "2023-01-01",
			endDay:   "2023-01-02",
			got: struct {
				DateRange       [][]string
				Day             int32
				MiddleDayString []string
			}{
				DateRange: [][]string{
					{"2022-12-13", "2023-01-02"},
				},
				Day:             11,
				MiddleDayString: []string{"2022-12-23"},
			},
		},
		{
			startDay: "2024-10-23",
			endDay:   "2024-10-24",
			got: struct {
				DateRange       [][]string
				Day             int32
				MiddleDayString []string
			}{
				DateRange: [][]string{
					{"2024-10-04", "2024-10-24"},
				},
				Day:             11,
				MiddleDayString: []string{"2024-10-14"},
			},
		},
		{
			startDay: "2024-06-22",
			endDay:   "2024-10-24",
			got: struct {
				DateRange       [][]string
				Day             int32
				MiddleDayString []string
			}{
				DateRange: [][]string{
					{"2024-06-21", "2024-07-11"},
					{"2024-07-12", "2024-08-01"},
					{"2024-08-02", "2024-08-22"},
					{"2024-08-23", "2024-09-12"},
					{"2024-09-13", "2024-10-03"},
					{"2024-10-04", "2024-10-24"},
				}, Day: 11,
				MiddleDayString: []string{"2024-07-01", "2024-07-22", "2024-08-12", "2024-09-02", "2024-09-23", "2024-10-14"},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.startDay, func(t *testing.T) {
			got, err := Get21DayPeriods(tt.startDay, tt.endDay)
			assert.Nil(t, err)
			assert.Equal(t, tt.got.DateRange, got)
			for i, v := range tt.got.DateRange {
				middleDate, err := GetRangeDayMiddleDay(v, tt.got.Day)
				assert.Nil(t, err)
				assert.Equal(t, tt.got.MiddleDayString[i], middleDate)
			}
		})
	}
}

func TestGetRangeDayByDays(t *testing.T) {
	tests := []struct {
		startDay string
		endDay   string
		days     int32
		got      [][]string
	}{
		{
			startDay: "2024-10-23",
			endDay:   "2024-10-24",
			days:     5,
			got: [][]string{
				{"2024-10-23", "2024-10-24"},
			},
		},
		{
			startDay: "2024-10-23",
			endDay:   "2024-10-24",
			days:     1,
			got: [][]string{
				{"2024-10-23", "2024-10-23"},
				{"2024-10-24", "2024-10-24"},
			},
		},
		{
			startDay: "2024-10-01",
			endDay:   "2024-10-31",
			days:     7,
			got: [][]string{
				{"2024-10-01", "2024-10-07"},
				{"2024-10-08", "2024-10-14"},
				{"2024-10-15", "2024-10-21"},
				{"2024-10-22", "2024-10-28"},
				{"2024-10-29", "2024-10-31"},
			},
		},
		{
			startDay: "2024-10-01",
			endDay:   "2024-10-31",
			days:     5,
			got: [][]string{
				{"2024-10-01", "2024-10-05"},
				{"2024-10-06", "2024-10-10"},
				{"2024-10-11", "2024-10-15"},
				{"2024-10-16", "2024-10-20"},
				{"2024-10-21", "2024-10-25"},
				{"2024-10-26", "2024-10-30"},
				{"2024-10-31", "2024-10-31"},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.startDay, func(t *testing.T) {
			got, err := GetRangeDayByDays(tt.startDay, tt.endDay, tt.days)
			assert.Nil(t, err)
			assert.Equal(t, tt.got, got)
		})
	}
}

func TestConfidenceInterval2(t *testing.T) {
	tests := []struct {
		p     float64
		total float64
		min   float64
		max   float64
	}{
		{
			p:     0.38,
			total: 114,
			min:   29,
			max:   47,
		},
		{
			p:     0.49,
			total: 142,
			min:   40,
			max:   58,
		},
		{
			p:     0.41,
			total: 125,
			min:   32,
			max:   50,
		},
		{
			p:     0,
			total: 0,
			min:   0,
			max:   0,
		},
	}

	for _, tt := range tests {
		min, max := ConfidenceInterval2(tt.p, tt.total)
		assert.Equal(t, tt.min, min)
		assert.Equal(t, tt.max, max)
	}
}

func TestRemoveDuplicates(t *testing.T) {
	tests := []struct {
		actual []string
		got    []string
	}{
		{
			actual: []string{
				"1", "1",
			},
			got: []string{
				"1",
			},
		},
		{
			actual: []string{
				"1", "1", "2",
			},
			got: []string{
				"1", "2",
			},
		},
		{
			actual: []string{
				"1",
			},
			got: []string{
				"1",
			},
		},
		{
			actual: []string{},
			got:    []string{},
		},
	}

	for _, tt := range tests {
		got := RemoveDuplicates(tt.actual)
		assert.Equal(t, tt.got, got)
	}

}

func TestDaysBetween(t *testing.T) {
	tests := []struct {
		actual []int64
		got    int64
	}{
		{
			actual: []int64{
				1730736000, // 2024-11-05 00:00:00
				1730772000, // 2024-11-05 10:00:00
			},
			got: 0,
		},
		{
			actual: []int64{
				1730772000, // 2024-11-05 10:00:00
				1730908800, // 2024-11-07 00:00:00
			},
			got: 2,
		},
		{
			actual: []int64{
				1730908800, // 2024-11-07 00:00:00
				1730772000, // 2024-11-05 10:00:00
			},
			got: -2,
		},
	}

	for _, v := range tests {
		got := DaysBetween(v.actual[0], v.actual[1])
		assert.Equal(t, got, v.got)
	}
}

func TestGetNeckRingActiveTimer(t *testing.T) {
	nowTime := time.Now().Format(Layout)
	tests := struct {
		frameId  []int32
		dateTime []string
		hours    []int32
	}{
		frameId: []int32{
			1, 2, 3, 4, 5, 6,
			11, 12, 13, 14, 15, 16,
			21, 22, 23, 24, 25, 26,
			31, 32, 33, 34, 35, 36,
			41, 42, 43, 44, 45, 46,
			51, 52, 53, 54, 55, 56,
			61, 62, 63, 64, 65, 66,
			71, 72, 73, 74, 75, 76,
			81, 82, 83, 84, 85, 86,
			91, 92, 93, 94, 95, 96,
			101, 102, 103, 104, 105, 106,
			111, 112, 113, 114, 115, 116,
			8, 18, 28, 38, 48, 58, 68, 78, 88, 98, 108, 118,
		},
		hours: []int32{
			0, 0, 1, 1, 1, 2,
			2, 2, 3, 3, 3, 4,
			4, 4, 5, 5, 5, 6,
			6, 6, 7, 7, 7, 8,
			8, 8, 9, 9, 9, 10,
			10, 10, 11, 11, 11, 12,
			12, 12, 13, 13, 13, 14,
			14, 14, 15, 15, 15, 16,
			16, 16, 17, 17, 17, 18,
			18, 18, 19, 19, 19, 20,
			20, 20, 21, 21, 21, 22,
			22, 22, 23, 23, 23, 24,
			2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 0,
		},
		dateTime: []string{
			fmt.Sprintf("%s 00:20:00", nowTime), fmt.Sprintf("%s 00:40:00", nowTime), fmt.Sprintf("%s 01:00:00", nowTime),
			fmt.Sprintf("%s 01:20:00", nowTime), fmt.Sprintf("%s 01:40:00", nowTime), fmt.Sprintf("%s 02:00:00", nowTime),
			fmt.Sprintf("%s 02:20:00", nowTime), fmt.Sprintf("%s 02:40:00", nowTime), fmt.Sprintf("%s 03:00:00", nowTime),
			fmt.Sprintf("%s 03:20:00", nowTime), fmt.Sprintf("%s 03:40:00", nowTime), fmt.Sprintf("%s 04:00:00", nowTime),
			fmt.Sprintf("%s 04:20:00", nowTime), fmt.Sprintf("%s 04:40:00", nowTime), fmt.Sprintf("%s 05:00:00", nowTime),
			fmt.Sprintf("%s 05:20:00", nowTime), fmt.Sprintf("%s 05:40:00", nowTime), fmt.Sprintf("%s 06:00:00", nowTime),
			fmt.Sprintf("%s 06:20:00", nowTime), fmt.Sprintf("%s 06:40:00", nowTime), fmt.Sprintf("%s 07:00:00", nowTime),
			fmt.Sprintf("%s 07:20:00", nowTime), fmt.Sprintf("%s 07:40:00", nowTime), fmt.Sprintf("%s 08:00:00", nowTime),
			fmt.Sprintf("%s 08:20:00", nowTime), fmt.Sprintf("%s 08:40:00", nowTime), fmt.Sprintf("%s 09:00:00", nowTime),
			fmt.Sprintf("%s 09:20:00", nowTime), fmt.Sprintf("%s 09:40:00", nowTime), fmt.Sprintf("%s 10:00:00", nowTime),
			fmt.Sprintf("%s 10:20:00", nowTime), fmt.Sprintf("%s 10:40:00", nowTime), fmt.Sprintf("%s 11:00:00", nowTime),
			fmt.Sprintf("%s 11:20:00", nowTime), fmt.Sprintf("%s 11:40:00", nowTime), fmt.Sprintf("%s 12:00:00", nowTime),
			fmt.Sprintf("%s 12:20:00", nowTime), fmt.Sprintf("%s 12:40:00", nowTime), fmt.Sprintf("%s 13:00:00", nowTime),
			fmt.Sprintf("%s 13:20:00", nowTime), fmt.Sprintf("%s 13:40:00", nowTime), fmt.Sprintf("%s 14:00:00", nowTime),
			fmt.Sprintf("%s 14:20:00", nowTime), fmt.Sprintf("%s 14:40:00", nowTime), fmt.Sprintf("%s 15:00:00", nowTime),
			fmt.Sprintf("%s 15:20:00", nowTime), fmt.Sprintf("%s 15:40:00", nowTime), fmt.Sprintf("%s 16:00:00", nowTime),
			fmt.Sprintf("%s 16:20:00", nowTime), fmt.Sprintf("%s 16:40:00", nowTime), fmt.Sprintf("%s 17:00:00", nowTime),
			fmt.Sprintf("%s 17:20:00", nowTime), fmt.Sprintf("%s 17:40:00", nowTime), fmt.Sprintf("%s 18:00:00", nowTime),
			fmt.Sprintf("%s 18:20:00", nowTime), fmt.Sprintf("%s 18:40:00", nowTime), fmt.Sprintf("%s 19:00:00", nowTime),
			fmt.Sprintf("%s 19:20:00", nowTime), fmt.Sprintf("%s 19:40:00", nowTime), fmt.Sprintf("%s 20:00:00", nowTime),
			fmt.Sprintf("%s 20:20:00", nowTime), fmt.Sprintf("%s 20:40:00", nowTime), fmt.Sprintf("%s 21:00:00", nowTime),
			fmt.Sprintf("%s 21:20:00", nowTime), fmt.Sprintf("%s 21:40:00", nowTime), fmt.Sprintf("%s 22:00:00", nowTime),
			fmt.Sprintf("%s 22:20:00", nowTime), fmt.Sprintf("%s 22:40:00", nowTime), fmt.Sprintf("%s 23:00:00", nowTime),
			fmt.Sprintf("%s 23:20:00", nowTime), fmt.Sprintf("%s 23:40:00", nowTime), fmt.Sprintf("%s 24:00:00", nowTime),

			fmt.Sprintf("%s 02:00:00", nowTime), fmt.Sprintf("%s 04:00:00", nowTime), fmt.Sprintf("%s 06:00:00", nowTime),
			fmt.Sprintf("%s 08:00:00", nowTime), fmt.Sprintf("%s 10:00:00", nowTime), fmt.Sprintf("%s 12:00:00", nowTime),
			fmt.Sprintf("%s 14:00:00", nowTime), fmt.Sprintf("%s 16:00:00", nowTime), fmt.Sprintf("%s 18:00:00", nowTime),
			fmt.Sprintf("%s 20:00:00", nowTime), fmt.Sprintf("%s 22:00:00", nowTime), fmt.Sprintf("%s 00:00:00", nowTime),
		},
	}

	for i, frameId := range tests.frameId {
		got, hours := GetNeckRingActiveTimer(frameId)
		t.Logf("frameId: %d, test-hours: %d,hours:%d  got :%s", frameId, tests.hours[i], hours, got)
		//assert.Equal(t, got, tests.dateTime[i])
		assert.Equal(t, int32(hours), tests.hours[i])
	}
}

func Test_demo(t *testing.T) {

	a := []int32{
		211670,
		9121372,
		3204736,
		3212694,
		3204532,
		3214082,
		9121667,
		3212275,
		3210345,
		3217879,
		9422,
		3206975,
		9496,
		3204907,
		212194,
		3211061,
		9120840,
		3207787,
		3210201,
		404,
		3207104,
		3219173,
		3216771,
		3216872,
		3209614,
		3205455,
		416,
		9121026,
		211622,
		3207868,
		3210340,
		9120132,
		3207092,
		3209390,
		3205872,
		3207367,
		3219700,
		9120022,
		211246,
		466,
		3207565,
		3208779,
		3204863,
		3207963,
		3204259,
		3207966,
		2640,
		3214316,
		3205778,
		3206897,
		3207745,
		3209052,
		3208045,
		211627,
		3212873,
		2100766,
		9121950,
		3206076,
		3206438,
		9466,
		9121195,
		9122044,
		3209430,
		3205599,
		2100794,
		3048,
		9467,
		3207480,
		3216011,
		9121725,
		9120340,
		9121597,
		427,
		3209387,
		3209490,
		3214311,
		3206044,
		211253,
		3207553,
		3215616,
		211350,
		3207551,
		3205896,
		417,
		9121008,
		3207694,
		3209372,
		3217873,
		3207227,
		3207568,
		3210615,
		3204769,
		3216095,
		9121338,
		3209124,
		211340,
		3219695,
		9121802,
		3205517,
		3210676,
		9123325,
		3204328,
		9409,
		211349,
		3208860,
		9121769,
		3209221,
		3210916,
		3205880,
		438,
		3205557,
		9421,
		211229,
		444,
		9123260,
		9121464,
		3212818,
		3204834,
		3205408,
		3207486,
		498,
		3206232,
		3206315,
		2100759,
		9121955,
		3204338,
		3207606,
		3208767,
		450,
		9123330,
		9121278,
		9121011,
		9122280,
		479,
		434,
		3207614,
		2355,
		211644,
		453,
		9121308,
		3209449,
		405,
		3204240,
		9120165,
		9445,
		9120456,
		9123057,
		471,
		3206830,
		464,
		403,
		2100749,
		3218278,
		3218600,
		212168,
		9470,
		428,
		3205448,
		3209790,
		3208163,
		213134,
		3207603,
		3206394,
		3204476,
		9121569,
		3206447,
		3209456,
		9120533,
		3209044,
		3214232,
		3209337,
		212193,
		3216684,
		3218450,
		3207194,
		3204853,
		3205858,
		3207922,
		3204645,
		212157,
		3214707,
		213126,
		3219468,
		9120766,
		3218611,
		3215948,
		3211568,
		9120227,
		211348,
		3212621,
		3209898,
		3207637,
		9121071,
		9123113,
		3206491,
		3209922,
		9440,
		3207075,
		423,
		3204875,
		9121888,
		3210395,
		9120630,
		9120214,
		3208166,
		211285,
		3206880,
		3209461,
		3205597,
		3216262,
		3204942,
		9123224,
		3205918,
		3204889,
		3209047,
		3207024,
		3207277,
		3207699,
		3205771,
		9500,
		3204450,
		3205495,
		9483,
		3209876,
		3205533,
		3216075,
		9469,
		3209827,
		9122454,
		413,
		3216308,
		3219301,
		3210042,
		3205064,
		211390,
		9121305,
		3218596,
		3204955,
		3215274,
		212171,
		3209460,
		3211376,
		3213812,
		3205184,
		3209287,
		3211769,
		3205926,
		3216585,
		3213332,
		3209340,
		9123175,
		3205843,
		3207663,
		3210829,
		3209481,
		9450,
		9463,
		3209763,
		3215627,
		9121424,
		3212746,
		3218533,
		3209072,
		3207359,
		3205888,
		3214228,
		3204884,
		3218613,
		3209352,
		3208192,
		3216211,
		3211454,
		3217082,
		3212728,
		3206984,
		3217750,
		3213406,
		3206305,
		9122130,
		9121695,
		9492,
		3207856,
		3218263,
		9121058,
		9123309,
		9122466,
		9122287,
		9120614,
		3084,
		3205559,
		3205840,
		9121444,
		9121777,
		3209308,
		9122313,
		9121672,
		3210180,
		3207645,
		3206419,
		9413,
		211576,
		3209201,
		2601,
		3211708,
		3206969,
		3206871,
		3210430,
		211674,
		9122441,
		3214386,
		3206927,
		3209332,
		9462,
		3206430,
		3207485,
		3204519,
		3216214,
		9123371,
		9120847,
		9123355,
		211690,
		3210362,
		3218862,
		3213687,
		3066,
		3209787,
		9120359,
		9468,
		2315,
		3207031,
		211353,
		211250,
		3207688,
		9122447,
		3218688,
		445,
		3205848,
		3214915,
		3208866,
		1739,
		3204990,
		2100716,
		212130,
		3204214,
		3208985,
		211388,
		9123166,
		3208856,
		211648,
		2311,
		3204411,
		3217860,
		9523,
		9524,
		3209134,
		3209212,
		211630,
		9123151,
		3207375,
		441,
		9525,
		3205815,
		3205527,
		3215344,
		3207185,
		211332,
		3217466,
		9526,
		1783,
		9122414,
		3207617,
		212150,
		3204248,
		3216316,
		3209535,
		3206873,
		3208974,
		9406,
		9122407,
		9121925,
		2351,
		3214481,
		3204826,
		3205906,
		3205109,
		3209014,
		211240,
		3070,
		474,
		3204667,
		3205511,
		409,
		3209061,
		3205074,
		3206009,
		9123010,
		3207536,
		3219231,
		3207198,
		9475,
		9423,
		9121871,
		3204643,
		3205471,
		3206095,
		9121981,
		9120835,
		3206427,
		3218217,
		3207493,
		2100732,
		3204886,
		3208174,
		9486,
		2100772,
		3209419,
		3207087,
		2328,
		3207371,
		3210597,
		3206231,
		3206931,
		3204236,
		3207411,
		3206374,
		3206452,
		3207472,
		9429,
		3218802,
		211381,
		9474,
		3204420,
		3207026,
		3206124,
		3209608,
		3209330,
		3209485,
		3216593,
		3205921,
		2375,
		3204818,
		3215544,
		3213632,
		3216924,
		3204395,
		3207111,
		3206961,
		212169,
		9123027,
		2100744,
		9520,
		3208708,
		3214104,
		3206329,
		9512,
		3211187,
		3207674,
		3206004,
		3207748,
		3209328,
		3209033,
		3205601,
		3205776,
		9438,
		3205269,
		3204664,
		9514,
		3204897,
		9446,
		3208827,
		3209611,
		3208050,
		9501,
		9121120,
		3213788,
		9121699,
		3204409,
		3210073,
		3207546,
		2100758,
		3206082,
		3208975,
		9122051,
		9518,
		3207751,
		9408,
		3206437,
		3207343,
		3207021,
		3216998,
		3205349,
		3214744,
		3205905,
		3212646,
		3209740,
		3206239,
		3207473,
		3207236,
		3209730,
		3204360,
		3206895,
		9120696,
		3204901,
		9508,
		3207935,
		3213977,
		3214166,
		448,
		3205893,
		3212052,
		3205552,
		3211112,
		3213551,
		3217077,
		3206322,
		9465,
		3208807,
		3205211,
		3215051,
		3207121,
		3215725,
		3207229,
		3219426,
		3213345,
		3217541,
		3216876,
		3215675,
		3214245,
		3207012,
		3218806,
		3217024,
		3212486,
		3207620,
		3211045,
		3213712,
		3215268,
		3215061,
		3209099,
		3218820,
		3212817,
		3204659,
		3210976,
		3213266,
		3211716,
		3207860,
		3213350,
		9517,
		3215001,
		3217667,
		3213039,
		3207248,
		9510,
		3215056,
		3218732,
		3216053,
		3209995,
		3215773,
		3211035,
		3213295,
		3205725,
		9464,
		3205636}

	value := ``
	for _, v := range a {
		value += fmt.Sprintf(`"%d",`, v)
	}

	fmt.Println(value)
}