Sign in

import (
	"net/http"
	"slices"
	"strings"
	"sync"

	"github.com/romshark/datapages"

	"example.com/shoplist/app/datapagesgen/href"
)

type Item struct {
	ID      int64
	Name    string
	Done    bool
	AddedBy string
}

// Add appends an item named name to the list.
func (a *App) Add(name, addedBy string) {
	a.mu.Lock()
	defer a.mu.Unlock()
	a.lastID++
	a.items = append(a.items, Item{ID: a.lastID, Name: name, AddedBy: addedBy})
}

// SessionData is what the session keeps about the signed-in user.
type SessionData struct {
	Name string
}

type Session = datapages.Session[SessionData]

// view is what the page renders for 1 tab.
type view struct {
	Items   []Item
	Editing int64  // ID of the item the tab renames, 0 for none
	User    string // name of the signed-in user, empty for a guest
}

func (p PageIndex) GET(
	r *http.Request,
	session Session,
) (body datapages.Component, err error) {
	return pageIndex(view{
		Items: p.App.Items(),
		User:  session.Data().Name,
	}), nil
}

// POSTAdd is /items
func (p PageIndex) POSTAdd(
	r *http.Request,
	sse datapages.SSE,
	session Session,
	signals datapages.Signals[struct {
		Name string `json:"name"`
	}],
	itemsChanged datapages.Dispatcher[EventItemsChanged],
) error {
	if session.IsGuest() {
		return datapages.ErrForbidden
	}
	name := strings.TrimSpace(signals.Values.Name)
	if name == "" {
		return datapages.ErrBadRequest
	}
	p.App.Add(name, session.Data().Name)
	if err := itemsChanged.Dispatch(EventItemsChanged{}); err != nil {
		return err
	}
	return sse.PatchSignals(map[string]string{"name": ""})
}

func (p PageIndex) OnItemsChanged(
	event EventItemsChanged,
	sse datapages.SSE,
	state datapages.State[StateIndex],
	session Session,
) error {
	return sse.PatchElement(itemList(view{
		Items:   p.App.Items(),
		Editing: state.Values.Editing,
		User:    session.Data().Name,
	}))
}

// POSTToggle is /items/{id}/toggle
func (p PageIndex) POSTToggle(
	r *http.Request,
	session Session,
	path datapages.Path[ItemPath],
	itemsChanged datapages.Dispatcher[EventItemsChanged],
) error {
	if session.IsGuest() {
		return datapages.ErrForbidden
	}
	if !p.App.Toggle(path.Values.ID) {
		return datapages.ErrNotFound
	}
	return itemsChanged.Dispatch(EventItemsChanged{})
}

// DELETEItem is /items/{id}
func (p PageIndex) DELETEItem(
	r *http.Request,
	session Session,
	path datapages.Path[ItemPath],
	itemsChanged datapages.Dispatcher[EventItemsChanged],
) error {
	if session.IsGuest() {
		return datapages.ErrForbidden
	}
	if !p.App.Remove(path.Values.ID) {
		return datapages.ErrNotFound
	}
	return itemsChanged.Dispatch(EventItemsChanged{})
}

// POSTEdit is /items/{id}/edit
func (p PageIndex) POSTEdit(
	r *http.Request,
	sse datapages.SSE,
	session Session,
	path datapages.Path[ItemPath],
	state datapages.State[StateIndex],
) error {
	if session.IsGuest() {
		return datapages.ErrForbidden
	}
	state.Values.Editing = path.Values.ID
	return sse.PatchElement(itemList(view{
		Items:   p.App.Items(),
		Editing: state.Values.Editing,
		User:    session.Data().Name,
	}))
}

// POSTRename is /items/{id}/rename
func (p PageIndex) POSTRename(
	r *http.Request,
	session Session,
	path datapages.Path[ItemPath],
	signals datapages.Signals[struct {
		Rename string `json:"rename"`
	}],
	state datapages.State[StateIndex],
	itemsChanged datapages.Dispatcher[EventItemsChanged],
) error {
	if session.IsGuest() {
		return datapages.ErrForbidden
	}
	name := strings.TrimSpace(signals.Values.Rename)
	if name == "" {
		return datapages.ErrBadRequest
	}
	if !p.App.Rename(path.Values.ID, name) {
		return datapages.ErrNotFound
	}
	state.Values.Editing = 0
	return itemsChanged.Dispatch(EventItemsChanged{})
}

// POSTSignIn is /sign-in
func (*App) POSTSignIn(
	r *http.Request,
	signals datapages.Signals[struct {
		User string `json:"user"`
	}],
) (
	newSession datapages.NewSession[SessionData],
	redirect datapages.Redirect,
	err error,
) {
	name := strings.TrimSpace(signals.Values.User)
	if err := datapages.ValidateUserID(name); err != nil {
		return newSession, redirect, datapages.ErrBadRequest
	}
	newSession = datapages.NewSession[SessionData]{
		UserID: name,
		Data:   SessionData{Name: name},
	}
	return newSession, datapages.Redirect{URL: href.PageIndex()}, nil
}

// POSTSignOut is /sign-out
func (*App) POSTSignOut(r *http.Request) (
	closeSession datapages.CloseSession,
	redirect datapages.Redirect,
	err error,
) {
	return true, datapages.Redirect{URL: href.PageIndex()}, nil
}

	// in main
	opts = append(opts, datapages.WithSessionManager[app.SessionData](sessionManager))

	s, err := datapages.NewServer[
		app.App,
		app.SessionData,
		datapages.EnablePrometheus,
		datapagesgen.Server,
	](a, messageBroker, opts...)

// in connectNATS
func connectNATS() (
	*natscore.MessageBroker,
	*natskv.SessionManager[app.SessionData],
) {

	sessionManager, err := natskv.New[app.SessionData](

package app

import (
	"fmt"

	"example.com/shoplist/app/datapagesgen/action"
)

templ pageIndex(v view) {
	<main>
		<h1>Shopping list</h1>
		if v.User == "" {
			<form data-on:submit__prevent={ action.App.SignIn.POST() }>
				<input data-bind="user" placeholder="Your name" required/>
				<button>Sign in</button>
			</form>
		} else {
			<p>
				Signed in as { v.User }
				<button data-on:click={ action.App.SignOut.POST() }>Sign out</button>
			</p>
			<form data-indicator:_adding data-on:submit__prevent={ action.PageIndex.Add.POST() }>
				<input data-bind="name" required/>
				<button data-attr:disabled="$_adding">Add</button>
			</form>
		}
		@itemList(v)
	</main>
}

templ itemList(v view) {
	<div id="items">
		if len(v.Items) == 0 {
			<p>Nothing to buy.</p>
		}
		<ul>
			for _, item := range v.Items {
				<li id={ fmt.Sprintf("item-%d", item.ID) }>
					if item.ID == v.Editing {
						<form
							data-signals:rename={ templ.JSONString(item.Name) }
							data-on:submit__prevent={ action.PageIndex.Rename.POST(item.ID) }
						>
							<input data-bind="rename" required/>
							<button>Save</button>
						</form>
					} else {
						if v.User != "" {
							<input
								type="checkbox"
								checked?={ item.Done }
								data-on:change={ action.PageIndex.Toggle.POST(item.ID) }
							/>
						}
						if item.Done {
							<s>{ item.Name }</s>
						} else {
							{ item.Name }
						}
						<small>{ item.AddedBy }</small>
						if v.User != "" {
							<button data-on:click={ action.PageIndex.Edit.POST(item.ID) }>Rename</button>
							<button data-on:click={ action.PageIndex.Item.DELETE(item.ID) }>Remove</button>
						}
					}
				</li>
			}
		</ul>
	</div>
}