openapi

func Build(title, version string, handlers ...any) ([]byte, error)

{
	doc := Document{
		OpenAPI: "3.0.3",
		Info: Info{
			Title:   title,
			Version: version,
		},
		Paths: map[string]PathItem{},
	}

	for _, h := range handlers {
		val := reflect.ValueOf(h)
		if val.Kind() == reflect.Ptr {
			val = val.Elem()
		}
		typ := val.Type()

		var method, path string
		extractTags(typ, &method, &path)

		if method == "" || path == "" {
			continue
		}

		op := Operation{
			Responses: map[string]Response{"200": {Description: "OK"}},
		}

		discoverParameters(typ, &op)

		if mp, ok := h.(MetaProvider); ok {
			m := mp.OpenAPIMeta()
			if s, ok := m["summary"].(string); ok {
				op.Summary = s
			}
			if d, ok := m["description"].(string); ok {
				op.Description = d
			}
			if params, ok := m["parameters"].([]map[string]any); ok {
				for _, pm := range params {
					p := Parameter{Name: pm["name"].(string), In: pm["in"].(string)}
					if req, ok := pm["required"].(bool); ok {
						p.Required = req
					}
					if sch, ok := pm["schema"].(map[string]any); ok {
						p.Schema.Type, _ = sch["type"].(string)
						if min, ok := sch["minimum"].(int); ok {
							f := float64(min)
							p.Schema.Minimum = &f
						}
					}
					op.Parameters = append(op.Parameters, p)
				}
			}
			if resp, ok := m["responses"].(map[int]any); ok {
				op.Responses = map[string]Response{}
				for code, desc := range resp {
					op.Responses[codeToStr(code)] = Response{Description: desc.(string)}
				}
			}
		}

		pathItem, ok := doc.Paths[path]
		if !ok {
			pathItem = make(PathItem)
		}
		pathItem[method] = op
		doc.Paths[path] = pathItem
	}

	return json.MarshalIndent(doc, "", "  ")
}

func goTypeToOpenAPI(t reflect.Type) string

{
	switch t.Kind() {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return "integer"
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return "integer"
	case reflect.Float32, reflect.Float64:
		return "number"
	case reflect.Bool:
		return "boolean"
	default:
		return "string"
	}
}

func extractTags(typ reflect.Type, method, path *string)

{
	for i := 0; i < typ.NumField(); i++ {
		field := typ.Field(i)
		if field.Anonymous {
			extractTags(field.Type, method, path)
		}
		if m := field.Tag.Get("method"); m != "" {
			*method = strings.ToLower(m)
		}
		if p := field.Tag.Get("path"); p != "" {
			*path = p
		}
	}
}

func discoverParameters(typ reflect.Type, op *Operation)

{
	for i := 0; i < typ.NumField(); i++ {
		field := typ.Field(i)
		if field.Anonymous {
			discoverParameters(field.Type, op)
			continue
		}
		if q := field.Tag.Get("query"); q != "" {
			p := Parameter{Name: q, In: "query", Schema: Schema{Type: goTypeToOpenAPI(field.Type)}}
			op.Parameters = append(op.Parameters, p)
		}
		if p := field.Tag.Get("path"); p != "" {
			param := Parameter{Name: p, In: "path", Required: true, Schema: Schema{Type: goTypeToOpenAPI(field.Type)}}
			op.Parameters = append(op.Parameters, param)
		}
		if h := field.Tag.Get("header"); h != "" {
			param := Parameter{Name: h, In: "header", Schema: Schema{Type: goTypeToOpenAPI(field.Type)}}
			op.Parameters = append(op.Parameters, param)
		}
	}
}

func TestBuild_BasicDocument(t *testing.T)

{
	doc, err := Build("Test API", "1.0.0", &TestEndpoint{})
	if err != nil {
		t.Fatalf("Build: %v", err)
	}

	var result Document
	if err := json.Unmarshal(doc, &result); err != nil {
		t.Fatalf("Unmarshal: %v", err)
	}

	if result.OpenAPI != "3.0.3" {
		t.Errorf("OpenAPI = %q, want 3.0.3", result.OpenAPI)
	}
	if result.Info.Title != "Test API" {
		t.Errorf("Title = %q, want Test API", result.Info.Title)
	}
	if result.Info.Version != "1.0.0" {
		t.Errorf("Version = %q, want 1.0.0", result.Info.Version)
	}

	pathItem, ok := result.Paths["/api/v1/test"]
	if !ok {
		t.Fatal("path /api/v1/test not found")
	}
	op, ok := pathItem["get"]
	if !ok {
		t.Fatal("method get not found")
	}
	if op.Summary != "Test endpoint" {
		t.Errorf("Summary = %q, want Test endpoint", op.Summary)
	}
}

func TestBuild_AutoParameters(t *testing.T)

{
	doc, err := Build("Test", "1.0.0", &TestEndpoint{})
	if err != nil {
		t.Fatalf("Build: %v", err)
	}

	var result Document
	json.Unmarshal(doc, &result)

	op := result.Paths["/api/v1/test"]["get"]

	foundQuery := false
	for _, p := range op.Parameters {
		if p.Name == "name" && p.In == "query" {
			foundQuery = true
		}
	}
	if !foundQuery {
		t.Error("expected query parameter 'name'")
	}
}

func TestGoTypeToOpenAPI(t *testing.T)

{
	tests := []struct {
		kind   string
		goType string
		want   string
	}{
		{"int", "int", "integer"},
		{"string", "string", "string"},
		{"float64", "float64", "number"},
		{"bool", "bool", "boolean"},
	}
	for _, tt := range tests {
		t.Run(tt.kind, func(t *testing.T) {
			_ = tt.want
		})
	}
}