CREATE TABLE idempotency_keys (
    key VARCHAR(255) PRIMARY KEY,
    user_id VARCHAR(64) NOT NULL,
    request_hash VARCHAR(64) NOT NULL,
    status VARCHAR(20) NOT NULL CHECK (status IN ('PROCESSING', 'COMPLETED', 'FAILED')),
    response_code INT NULL,
    response_body JSONB NULL,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

CREATE INDEX idx_idempotency_created ON idempotency_keys(created_at);

package idempotency

import (
	"bytes"
	"context"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"time"

	"github.com/redis/go-redis/v9"
)

type CachedResponse struct {
	StatusCode int               `json:"status_code"`
	Headers    map[string]string `json:"headers"`
	Body       []byte            `json:"body"`
}

type Middleware struct {
	rdb *redis.Client
	ttl time.Duration
}

func NewMiddleware(rdb *redis.Client, ttl time.Duration) *Middleware {
	return &Middleware{rdb: rdb, ttl: ttl}
}

// responseRecorder untuk menangkap status code dan body sebelum dikirim ke client
type responseRecorder struct {
	http.ResponseWriter
	statusCode int
	body       bytes.Buffer
}

func (rec *responseRecorder) WriteHeader(code int) {
	rec.statusCode = code
	rec.ResponseWriter.WriteHeader(code)
}

func (rec *responseRecorder) Write(b []byte) (int, error) {
	rec.body.Write(b)
	return rec.ResponseWriter.Write(b)
}

func (m *Middleware) Handler(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// Hanya terapkan pada method non-idempotent (POST, PATCH)
		if r.Method != http.MethodPost && r.Method != http.MethodPatch {
			next.ServeHTTP(w, r)
			return
		}

		key := r.Header.Get("Idempotency-Key")
		if key == "" {
			http.Error(w, `{"error":"Idempotency-Key header is required"}`, http.StatusBadRequest)
			return
		}

		ctx := r.Context()
		redisKey := fmt.Sprintf("idempotency:%s", key)

		// 1. Baca request body untuk menghitung payload hash
		bodyBytes, err := io.ReadAll(r.Body)
		if err != nil {
			http.Error(w, `{"error":"failed to read request body"}`, http.StatusInternalServerError)
			return
		}
		r.Body = io.NopCloser(bytes.NewBuffer(bodyBytes)) // restore body

		reqHash := calculateHash(bodyBytes)

		// 2. Cek apakah key sudah pernah diproses (Redis SETNX sebagai distributed lock)
		lockAcquired, err := m.rdb.SetNX(ctx, redisKey+":lock", reqHash, 30*time.Second).Result()
		if err != nil {
			http.Error(w, `{"error":"internal storage error"}`, http.StatusInternalServerError)
			return
		}

		if !lockAcquired {
			// Lock sudah dipegang request lain atau sudah selesai
			cachedData, err := m.rdb.Get(ctx, redisKey+":data").Bytes()
			if err == nil {
				// Response sudah siap: kembalikan cached response
				var resp CachedResponse
				if err := json.Unmarshal(cachedData, &resp); err == nil {
					for k, v := range resp.Headers {
						w.Header().Set(k, v)
					}
					w.Header().Set("X-Cache-Lookup", "HIT-IDEMPOTENT")
					w.WriteHeader(resp.StatusCode)
					_, _ = w.Write(resp.Body)
					return
				}
			}

			// Masih dalam proses
			http.Error(w, `{"error":"request is currently being processed"}`, http.StatusConflict)
			return
		}

		// 3. Eksekusi handler asli dan rekam responnya
		rec := &responseRecorder{
			ResponseWriter: w,
			statusCode:     http.StatusOK,
		}

		next.ServeHTTP(rec, r)

		// 4. Simpan response sukses ke Redis
		if rec.statusCode >= 200 && rec.statusCode < 500 {
			cachedResp := CachedResponse{
				StatusCode: rec.statusCode,
				Headers: map[string]string{
					"Content-Type": rec.Header().Get("Content-Type"),
				},
				Body: rec.body.Bytes(),
			}
			respBytes, _ := json.Marshal(cachedResp)
			_ = m.rdb.Set(ctx, redisKey+":data", respBytes, m.ttl).Err()
		}

		// Hapus lock processing
		_ = m.rdb.Del(ctx, redisKey+":lock").Err()
	})
}

func calculateHash(data []byte) string {
	sum := sha256.Sum256(data)
	return hex.EncodeToString(sum[:])
}

func validatePayloadMismatch(existingHash, currentHash string) error {
	if existingHash != currentHash {
		return errors.New("idempotency key reused with different request payload")
	}
	return nil
}