package database

import (
	"context"
	"strings"
	"testing"

	"modelRT/model"
	modelsql "modelRT/sql"

	"github.com/DATA-DOG/go-sqlmock"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"
)

func TestMeasurementInitializationSQLJoinsRequiredHierarchy(t *testing.T) {
	statement := compactMeasurementSQL(modelsql.MeasurementInitializationRows)

	assert.Contains(t, statement, "component.station_id = station.id")
	assert.Contains(t, statement, "measurement.component_uuid = component.global_uuid")
	assert.Contains(t, statement, "bay.bay_uuid = measurement.bay_uuid")
	assert.Contains(t, statement, "measurement.type AS measurement_type")
	assert.Contains(t, statement, "measurement.tag <> ''")
	assert.NotContains(t, strings.ToLower(statement), "dev_")
}

func TestQueryMeasurementInitializationRecords(t *testing.T) {
	sqlDB, mock, err := sqlmock.New()
	require.NoError(t, err)
	t.Cleanup(func() { _ = sqlDB.Close() })

	db, err := gorm.Open(postgres.New(postgres.Config{Conn: sqlDB}), &gorm.Config{})
	require.NoError(t, err)

	mock.ExpectQuery(`(?s)SELECT.*FROM public\.grid.*INNER JOIN public\.zone.*INNER JOIN public\.station.*INNER JOIN public\.component.*INNER JOIN public\.measurement.*INNER JOIN public\.bay`).
		WillReturnRows(measurementInitializationRows().
			AddRow(
				"grid000",
				"zone000",
				"station000",
				"component-uuid",
				"nspath",
				"component",
				int64(10),
				"IA_rms",
				"A相保护电流有效值",
				int16(0),
				int16(1),
				1,
				`{"type":1,"io_address":{"channel":"TM1"}}`,
				`{}`,
				`{"ct":{"ratio":1250}}`,
			))

	records, err := QueryMeasurementInitializationRecords(context.Background(), db)
	require.NoError(t, err)
	require.Len(t, records, 1)
	assert.Equal(t, int64(10), records[0].MeasurementID)
	assert.Equal(t, "IA_rms", records[0].MeasurementTag)
	assert.Equal(t, int16(0), records[0].MeasurementType)
	assert.Equal(t, float64(1), records[0].MeasurementDataSource["type"])
	require.NoError(t, mock.ExpectationsWereMet())
}

func TestValidateMeasurementInitializationRecords(t *testing.T) {
	record := validMeasurementInitializationRecord()

	invalidMode := record
	invalidMode.MeasurementMode = 3
	err := validateMeasurementInitializationRecords([]model.MeasurementInitializationRecord{invalidMode})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "mode must be 0 or 1")

	emptySegment := record
	emptySegment.ComponentNSPath = ""
	err = validateMeasurementInitializationRecords([]model.MeasurementInitializationRecord{emptySegment})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "empty data-object token segment")

	nullDataSource := record
	nullDataSource.MeasurementDataSource = nil
	err = validateMeasurementInitializationRecords([]model.MeasurementInitializationRecord{nullDataSource})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "null data_source")

	invalidType := record
	invalidType.MeasurementType = -1
	err = validateMeasurementInitializationRecords([]model.MeasurementInitializationRecord{invalidType})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "unsupported measurement type -1")
}

func measurementInitializationRows() *sqlmock.Rows {
	return sqlmock.NewRows([]string{
		"grid_tag",
		"zone_tag",
		"station_tag",
		"component_uuid",
		"component_nspath",
		"component_tag",
		"measurement_id",
		"measurement_tag",
		"measurement_name",
		"measurement_type",
		"measurement_mode",
		"measurement_size",
		"measurement_data_source",
		"measurement_event_plan",
		"measurement_binding",
	})
}

func validMeasurementInitializationRecord() model.MeasurementInitializationRecord {
	return model.MeasurementInitializationRecord{
		GridTag:               "grid",
		ZoneTag:               "zone",
		StationTag:            "station",
		ComponentUUID:         "component-uuid",
		ComponentNSPath:       "nspath",
		ComponentTag:          "component",
		MeasurementID:         1,
		MeasurementTag:        "measurement",
		MeasurementType:       0,
		MeasurementMode:       1,
		MeasurementDataSource: map[string]any{},
		MeasurementEventPlan:  map[string]any{},
		MeasurementBinding:    map[string]any{},
	}
}