package mingqian

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"
	"strings"
	"testing"

	"git.5iot.com/iotlcm-public/iotlcm-upstream-chan/internal/model"
)

func TestPackageFlowFailuresPreserveMonthlyUsage(t *testing.T) {
	cases := []struct {
		name string
		body string
	}{
		{"business failure", `{"code":500,"msg":"private upstream detail","data":[]}`},
		{"missing card", `{"code":200,"data":[]}`},
		{"duplicate card", `{"code":200,"data":[{"iccid":"A","totalpackage":10,"targetpackageusage":2},{"iccid":"A","totalpackage":10,"targetpackageusage":2}]}`},
		{"missing total", `{"code":200,"data":[{"iccid":"A","targetpackageusage":2}]}`},
		{"missing usage", `{"code":200,"data":[{"iccid":"A","totalpackage":10}]}`},
		{"null total", `{"code":200,"data":[{"iccid":"A","totalpackage":null,"targetpackageusage":2}]}`},
		{"negative total", `{"code":200,"data":[{"iccid":"A","totalpackage":-1,"targetpackageusage":2}]}`},
		{"negative usage", `{"code":200,"data":[{"iccid":"A","totalpackage":10,"targetpackageusage":-1}]}`},
		{"nonfinite total", `{"code":200,"data":[{"iccid":"A","totalpackage":"NaN","targetpackageusage":2}]}`},
		{"invalid usage", `{"code":200,"data":[{"iccid":"A","totalpackage":10,"targetpackageusage":""}]}`},
	}
	for _, test := range cases {
		t.Run(test.name, func(t *testing.T) {
			adapter := testAdapter(t, func(writer http.ResponseWriter, request *http.Request) {
				if request.URL.Path == usagePath {
					fmt.Fprint(writer, `{"code":200,"data":[{"iccid":"A","use":1024}]}`)
					return
				}
				fmt.Fprint(writer, test.body)
			})
			output, err := adapter.QuerySimDataUsage(context.Background(), &model.SimDataUsageInput{SimKeys: []*model.SimKey{{ICCID: "A"}}})
			if err != nil || len(output) != 1 {
				t.Fatalf("output=%+v err=%v", output, err)
			}
			item := output[0]
			if item.Code != 0 || item.ResData.DataUsage != 1 || item.ResData.PackageFlow != nil || item.ResData.PackageFlowError == "" || item.Message == "" {
				t.Fatalf("must retain monthly usage with an explicit package failure: %+v", item)
			}
			if strings.Contains(item.ResData.PackageFlowError, "private upstream detail") {
				t.Fatal("raw upstream errors must not leak")
			}
		})
	}
}

func TestPackageFlowNeverSubstitutesForMonthlyUsage(t *testing.T) {
	adapter := testAdapter(t, func(writer http.ResponseWriter, request *http.Request) {
		if request.URL.Path == usagePath {
			writer.WriteHeader(http.StatusBadGateway)
			return
		}
		fmt.Fprint(writer, `{"code":200,"data":[{"iccid":"A","totalpackage":10,"targetpackageusage":8}]}`)
	})
	output, err := adapter.QuerySimDataUsage(context.Background(), &model.SimDataUsageInput{SimKeys: []*model.SimKey{{ICCID: "A"}}})
	if err != nil || len(output) != 1 || output[0].Code == 0 || !strings.Contains(output[0].Message, "502") {
		t.Fatalf("monthly failure must remain a failure: %+v, %v", output, err)
	}
	if output[0].ResData.DataUsage != 0 || output[0].ResData.PackageFlow == nil || output[0].ResData.PackageFlow.DataUsage != 8 {
		t.Fatal("package usage must not become monthly usage")
	}
}

func TestPackageFlowPerCardMatchingAndZero(t *testing.T) {
	adapter := testAdapter(t, func(writer http.ResponseWriter, request *http.Request) {
		if request.URL.Path == usagePath {
			fmt.Fprint(writer, `{"code":200,"data":[{"iccid":"A","use":0},{"msisdn":"144000","use":512},{"iccid":"missing-package","use":2048}]}`)
			return
		}
		fmt.Fprint(writer, `{"code":200,"data":[{"msisdn":"144000","totalpackage":"1.5","targetpackageusage":"2.25"},{"iccid":"A","totalpackage":0,"targetpackageusage":0}]}`)
	})
	keys := []*model.SimKey{{ICCID: " A "}, {MSISDN: "144000"}, {ICCID: "missing-package"}, {ICCID: "A"}}
	output, err := adapter.QuerySimDataUsage(context.Background(), &model.SimDataUsageInput{SimKeys: keys})
	if err != nil || len(output) != len(keys) {
		t.Fatalf("output=%+v err=%v", output, err)
	}
	for index, item := range output {
		if item.Code != 0 || item.SimKey != keys[index] {
			t.Fatalf("identity or monthly status changed: %+v", item)
		}
	}
	if output[0].ResData.PackageFlow == nil || *output[0].ResData.PackageFlow != (model.SimPackageFlowItem{}) || output[3].ResData.PackageFlow == nil {
		t.Fatal("zero flow is valid and duplicate request identifiers must retain their results")
	}
	flow := output[1].ResData.PackageFlow
	if flow == nil || flow.TotalFlow != 1.5 || flow.DataUsage != 2.25 || flow.RemainingFlow != 0 || output[1].ResData.DataUsage != 0.5 {
		t.Fatalf("incorrect overage or units: %+v", flow)
	}
	if output[2].ResData.PackageFlow != nil || output[2].ResData.PackageFlowError == "" {
		t.Fatal("missing package card must not be reported as zero")
	}
}

func TestFlowBothEndpointsBatchAtFifty(t *testing.T) {
	calls := map[string]int{}
	adapter := testAdapter(t, func(writer http.ResponseWriter, request *http.Request) {
		calls[request.URL.Path]++
		var payload struct {
			Data string `json:"data"`
		}
		var data struct {
			Numbers []string `json:"numberArray"`
		}
		if err := json.NewDecoder(request.Body).Decode(&payload); err != nil {
			t.Error(err)
		}
		if err := json.Unmarshal([]byte(payload.Data), &data); err != nil {
			t.Error(err)
		}
		if len(data.Numbers) == 0 || len(data.Numbers) > 50 {
			t.Errorf("wrong batch size: %d", len(data.Numbers))
		}
		rows := []map[string]any{}
		for _, identifier := range data.Numbers {
			rows = append(rows, map[string]any{"iccid": identifier, "use": 1024, "totalpackage": 10, "targetpackageusage": 8})
		}
		json.NewEncoder(writer).Encode(map[string]any{"code": 200, "data": rows})
	})
	keys := make([]*model.SimKey, 51)
	for index := range keys {
		keys[index] = &model.SimKey{ICCID: strconv.Itoa(index)}
	}
	output, err := adapter.QuerySimDataUsage(context.Background(), &model.SimDataUsageInput{SimKeys: keys})
	if err != nil || len(output) != 51 || calls[usagePath] != 2 || calls[packageUsagePath] != 2 {
		t.Fatalf("calls=%v count=%d err=%v", calls, len(output), err)
	}
	for _, item := range output {
		if item.Code != 0 || item.ResData.DataUsage != 1 || item.ResData.PackageFlow == nil || item.ResData.PackageFlow.RemainingFlow != 2 {
			t.Fatalf("incomplete mapping: %+v", item)
		}
	}
}

func TestFlowEmptyInputAndUnsupportedQueries(t *testing.T) {
	calls := 0
	adapter := testAdapter(t, func(writer http.ResponseWriter, request *http.Request) { calls++ })
	if _, err := adapter.QuerySimDataUsage(context.Background(), nil); err == nil {
		t.Fatal("nil input must fail")
	}
	output, err := adapter.QuerySimDataUsage(context.Background(), &model.SimDataUsageInput{})
	if err != nil || len(output) != 0 {
		t.Fatalf("empty input: %+v %v", output, err)
	}
	keys := []*model.SimKey{{ICCID: "A"}}
	session, _ := adapter.QuerySimSession(context.Background(), &model.SimSessionInput{SimKeys: keys})
	monthly, _ := adapter.QuerySimDataUsageMonthly(context.Background(), &model.SimDataUsageMonthlyInput{SimKeys: keys})
	daily, _ := adapter.QuerySimDataUsageDaily(context.Background(), &model.SimDataUsageDailyInput{SimKeys: keys})
	if session[0].Code == 0 || monthly[0].Code == 0 || daily[0].Code == 0 || calls != 0 {
		t.Fatal("unsupported queries must not invent data or contact upstream")
	}
}