package handlers

import (
	"fmt"
	"html/template"
	"io"
)

// Renderer abstracts template rendering for testability.
type Renderer interface {
	Render(w io.Writer, name string, data interface{}) error
}

// TemplateRenderer wraps *template.Template to implement Renderer.
type TemplateRenderer struct {
	templates *template.Template
}

// NewTemplateRenderer creates a new TemplateRenderer.
func NewTemplateRenderer(tmpl *template.Template) *TemplateRenderer {
	return &TemplateRenderer{templates: tmpl}
}

// Render executes the named template with the given data.
func (r *TemplateRenderer) Render(w io.Writer, name string, data interface{}) error {
	if r.templates == nil {
		return fmt.Errorf("templates not loaded")
	}
	return r.templates.ExecuteTemplate(w, name, data)
}

// Compile-time interface check
var _ Renderer = (*TemplateRenderer)(nil)

// MockRenderer is a test double for Renderer.
type MockRenderer struct {
	RenderFunc func(w io.Writer, name string, data interface{}) error
	Calls      []RenderCall
}

// RenderCall records a call to Render.
type RenderCall struct {
	Name string
	Data interface{}
}

// Render implements Renderer for testing.
func (m *MockRenderer) Render(w io.Writer, name string, data interface{}) error {
	m.Calls = append(m.Calls, RenderCall{Name: name, Data: data})
	if m.RenderFunc != nil {
		return m.RenderFunc(w, name, data)
	}
	fmt.Fprintf(w, "rendered:%s", name)
	return nil
}

// NewMockRenderer creates a new MockRenderer.
func NewMockRenderer() *MockRenderer {
	return &MockRenderer{}
}

// Compile-time interface check
var _ Renderer = (*MockRenderer)(nil)