main.go

// Package main demonstrates API response formatting.
package main

import (
	"encoding/json"
	"errors"
	"fmt"

	"github.com/yigithankarabulut/wirekit"
	"github.com/yigithankarabulut/wirekit/response"
)

// User represents a user in the system.
type User struct {
	ID    int    `json:"id"`
	Name  string `json:"name"`
	Email string `json:"email"`
}

func printJSON(label string, v any) {
	data, _ := json.MarshalIndent(v, "  ", "  ")
	fmt.Printf("%s\n  %s\n", label, string(data))
}

// SuccessResponses demonstrates success response types.
func SuccessResponses() {
	fmt.Println("\n--- Success Responses ---")

	// Simple success with data
	user := User{ID: 1, Name: "John Doe", Email: "john@example.com"}
	successResp := wirekit.Response.Success(user)
	printJSON("Success:", successResp)

	// Success with message only
	msgResp := wirekit.Response.SuccessMessage("Operation completed successfully")
	printJSON("Success Message:", msgResp)

	// Created response
	newUser := User{ID: 2, Name: "Jane Doe", Email: "jane@example.com"}
	createdResp := wirekit.Response.Created(newUser)
	printJSON("Created:", createdResp)

	// No content response
	noContentResp := wirekit.Response.NoContent()
	printJSON("No Content:", noContentResp)
}

// ErrorResponses demonstrates error response types.
func ErrorResponses() {
	fmt.Println("\n--- Error Responses ---")

	// Fail with error
	err := errors.New("something went wrong")
	failResp := wirekit.Response.Fail(err)
	printJSON("Fail:", failResp)

	// Fail with status code
	codeResp := wirekit.Response.FailWithCode(404)
	printJSON("Fail with Code:", codeResp)

	// Fail with message
	msgFailResp := wirekit.Response.FailWithMessage("Invalid input provided")
	printJSON("Fail with Message:", msgFailResp)

	// Fail with code and message
	codeAndMsgResp := wirekit.Response.FailWithCodeAndMessage(422, "Validation failed")
	printJSON("Fail with Code and Message:", codeAndMsgResp)
}

// HTTPStatusResponses demonstrates HTTP status responses.
func HTTPStatusResponses() {
	fmt.Println("\n--- HTTP Status Responses ---")

	// Bad Request (400)
	badReqResp := wirekit.Response.BadRequest("Invalid JSON format")
	printJSON("Bad Request:", badReqResp)

	// Unauthorized (401)
	unauthResp := wirekit.Response.Unauthorized("Token expired")
	printJSON("Unauthorized:", unauthResp)

	// Forbidden (403)
	forbiddenResp := wirekit.Response.Forbidden("Insufficient permissions")
	printJSON("Forbidden:", forbiddenResp)

	// Not Found (404)
	notFoundResp := wirekit.Response.NotFound("User not found")
	printJSON("Not Found:", notFoundResp)

	// Internal Server Error (500)
	internalResp := wirekit.Response.InternalError("")
	printJSON("Internal Error:", internalResp)
}

// PaginatedResponses demonstrates paginated response types.
func PaginatedResponses() {
	fmt.Println("\n--- Paginated Responses ---")

	users := []User{
		{ID: 1, Name: "Alice", Email: "alice@example.com"},
		{ID: 2, Name: "Bob", Email: "bob@example.com"},
		{ID: 3, Name: "Charlie", Email: "charlie@example.com"},
	}

	// Using generic paginated function for type safety
	paginatedResp := response.Paginated(users, 1, 10, 25)
	printJSON("Paginated (Page 1):", paginatedResp)

	// Page 2
	page2Resp := response.Paginated(users, 2, 10, 25)
	printJSON("Paginated (Page 2):", page2Resp)

	// Last page
	lastPageResp := response.Paginated(users, 3, 10, 25)
	printJSON("Paginated (Last Page):", lastPageResp)
}

// GenericTypedResponses demonstrates type-safe generic responses.
func GenericTypedResponses() {
	fmt.Println("\n--- Generic Typed Responses ---")

	user := User{ID: 1, Name: "John Doe", Email: "john@example.com"}

	// Type-safe success response
	typedResp := response.Success(user)
	printJSON("Typed Success:", typedResp)

	// Access typed data
	fmt.Printf("  Typed Data: ID=%d, Name=%s\n", typedResp.Data.ID, typedResp.Data.Name)
}

func main() {
	wirekit.Log(wirekit.Zap).WithLevel("info").Init()

	SuccessResponses()
	ErrorResponses()
	HTTPStatusResponses()
	PaginatedResponses()
	GenericTypedResponses()

	wirekit.Info("response example completed")
}