package parser

import (
	"encoding/json"
	"testing"

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

	caasmmodel "security-center-backend/internal/modules/caasm/model"
)

func TestParseKongYAMLNormalizesRoutesAndDeduplicates(t *testing.T) {
	raw := `
- domains:
    prod:
      - api.example.com
    test: test-api.example.com
  ingressNamePrefix: public-api
  ingresses:
    - prod: app-prod
      test: app-test
      services:
        - serviceName: user-service
          servicePort: 8080
          testCases:
            - /api/users
            - /api/users
          regex: /api/users/[0-9]+
          plugins: cors, jwt-auth
          external: "true"
          stripPath: "true"
        - serviceName: order-service
          servicePort: "9090"
          testCases:
            - /api/orders
`

	result, err := ParseKongYAML(raw)
	require.NoError(t, err)
	require.NotNil(t, result)
	require.Len(t, result.Assets, 3)

	first := result.Assets[0]
	assert.Equal(t, caasmmodel.APIRouteKindTestCase, first.RouteKind)
	assert.Equal(t, "/api/users", first.RoutePath)
	assert.Equal(t, "user-service", first.ServiceName)
	require.NotNil(t, first.ServicePort)
	assert.Equal(t, 8080, *first.ServicePort)
	assert.True(t, first.External)
	assert.True(t, first.StripPath)
	assert.Equal(t, []string{"cors", "jwt-auth"}, []string(first.Plugins))
	assert.Equal(t, 2, first.OccurrenceCount)

	var domains map[string][]string
	require.NoError(t, json.Unmarshal(first.Domains, &domains))
	assert.Equal(t, []string{"api.example.com"}, domains["prod"])
	assert.Equal(t, []string{"test-api.example.com"}, domains["test"])

	var namespaceMap map[string]string
	require.NoError(t, json.Unmarshal(first.NamespaceMap, &namespaceMap))
	assert.Equal(t, "app-prod", namespaceMap["prod"])
	assert.Equal(t, "app-test", namespaceMap["test"])

	assert.Equal(t, caasmmodel.APIRouteKindRegex, result.Assets[1].RouteKind)
	assert.Equal(t, "/api/users/[0-9]+", result.Assets[1].RoutePath)
	assert.Equal(t, "order-service", result.Assets[2].ServiceName)
	require.NotNil(t, result.Assets[2].ServicePort)
	assert.Equal(t, 9090, *result.Assets[2].ServicePort)
	assert.False(t, result.Assets[2].External)
	assert.False(t, result.Assets[2].StripPath)
}

func TestParseKongYAMLRejectsEmptyInput(t *testing.T) {
	result, err := ParseKongYAML("   ")
	require.Error(t, err)
	assert.Nil(t, result)
	assert.Contains(t, err.Error(), "raw_yaml is required")
}