Unidirectional data flow.

export type Step = 'you' | 'home' | 'pet' | 'review';
export type Field = 'name' | 'email' | 'homeType' | 'petId';
export type Answers = Record<Field, string>;
export type Status = 'saved' | 'unsaved' | 'saving' | 'failed';

export type Action =
	| { type: 'edit'; field: Field; value: string }
	| { type: 'next' }
	| { type: 'back' }
	| { type: 'undo' }
	| { type: 'reset' }
	| { type: 'autosave' }
	| { type: 'save-finished'; id: number; ok: boolean };

export interface WizardState {
	readonly step: Step;
	readonly answers: Answers;
	readonly past: readonly { step: Step; answers: Answers }[];
	readonly version: number;
	readonly savedVersion: number;
	/** The save the page should send, if any. Its id is how its reply is recognized. */
	readonly request: { id: number; version: number; answers: Answers } | null;
	readonly queued: boolean;
	readonly failed: boolean;
	readonly error: string | null;
	readonly lastId: number;
}

export const steps: readonly Step[] = ['you', 'home', 'pet', 'review'];
const required: Record<Step, Field[]> = {
	you: ['name', 'email'],
	home: ['homeType'],
	pet: ['petId'],
	review: []
};
export const empty: Answers = { name: '', email: '', homeType: '', petId: '' };

export const initialState: WizardState = {
	step: 'you',
	answers: empty,
	past: [],
	version: 0,
	savedVersion: 0,
	request: null,
	queued: false,
	failed: false,
	error: null,
	lastId: 0
};

const same = (a: Answers, b: Answers) =>
	(Object.keys(a) as Field[]).every((field) => a[field] === b[field]);

/** Asks for a save of what is on screen now. The page sends it; the reducer only decides. */
function send(state: WizardState): WizardState {
	const id = state.lastId + 1;
	return {
		...state,
		lastId: id,
		queued: false,
		request: { id, version: state.version, answers: state.answers }
	};
}

/** The one place the wizard's state changes. Pure: same state and action, same result. */
export function reduce(state: WizardState, action: Action): WizardState {
	const at = { step: state.step, answers: state.answers };
	const move = (by: number) => steps[steps.indexOf(state.step) + by];
	switch (action.type) {
		case 'edit':
			if (state.answers[action.field] === action.value) return { ...state, error: null };
			return {
				...state,
				past: [...state.past, at],
				answers: { ...state.answers, [action.field]: action.value },
				version: state.version + 1,
				error: null
			};
		case 'next': {
			const gaps = required[state.step].filter((field) => !state.answers[field].trim());
			if (gaps.length) return { ...state, error: `missing: ${gaps.join(', ')}` };
			if (state.step === 'review') return { ...state, error: null };
			return { ...state, past: [...state.past, at], step: move(1), error: null };
		}
		case 'back':
			if (state.step === 'you') return { ...state, error: null };
			return { ...state, past: [...state.past, at], step: move(-1), error: null };
		case 'undo': {
			const last = state.past.at(-1);
			if (!last) return { ...state, error: null };
			return {
				...state,
				past: state.past.slice(0, -1),
				step: last.step,
				answers: last.answers,
				version: same(last.answers, state.answers) ? state.version : state.version + 1,
				error: null
			};
		}
		case 'reset':
			// Start over. A save already sent is forgotten here, not canceled on the server.
			return {
				...state,
				step: 'you',
				answers: empty,
				past: [],
				version: state.version + 1,
				request: null,
				queued: false,
				failed: false,
				error: null
			};
		case 'autosave':
			if (state.request) return { ...state, queued: true, error: null };
			if (state.version === state.savedVersion) return { ...state, error: null };
			return send({ ...state, error: null });
		case 'save-finished': {
			// A reply for a save this state did not send is ignored, not trusted.
			if (!state.request || action.id !== state.request.id) return state;
			const settled: WizardState = action.ok
				? { ...state, request: null, savedVersion: state.request.version, failed: false }
				: { ...state, request: null, failed: true };
			return settled.queued && settled.version !== settled.savedVersion
				? send(settled)
				: { ...settled, queued: false };
		}
	}
}

export function status(state: WizardState): Status {
	if (state.request) return 'saving';
	if (state.version === state.savedVersion) return 'saved';
	return state.failed ? 'failed' : 'unsaved';
}

type Answers struct {
	Name     string `json:"name"`
	Email    string `json:"email"`
	HomeType string `json:"homeType"`
	PetID    string `json:"petId"`
}

func (a *Answers) set(field, value string) {
	switch field {
	case "name":
		a.Name = value
	case "email":
		a.Email = value
	case "homeType":
		a.HomeType = value
	case "petId":
		a.PetID = value
	}
}

func (a Answers) get(field string) string {
	return map[string]string{"name": a.Name, "email": a.Email, "homeType": a.HomeType, "petId": a.PetID}[field]
}

var Steps = []string{"you", "home", "pet", "review"}
var required = map[string][]string{"you": {"name", "email"}, "home": {"homeType"}, "pet": {"petId"}, "review": {}}

type Action struct {
	Type  string // edit, next, back, undo, autosave, save-finished
	Field string
	Value string
	ID    int
	OK    bool
}

type snapshot struct {
	Step    string
	Answers Answers
}

type Request struct {
	ID      int
	Version int
	Answers Answers
}

type State struct {
	Step         string
	Answers      Answers
	Past         []snapshot
	Version      int
	SavedVersion int
	Request      *Request // the save the page should send; its ID recognizes the reply
	Queued       bool
	Failed       bool
	Error        string
	LastID       int
}

func Initial() State { return State{Step: "you"} }

func index(step string) int {
	for i, s := range Steps {
		if s == step {
			return i
		}
	}
	return 0
}

func send(s State) State {
	s.LastID++
	s.Queued = false
	s.Request = &Request{ID: s.LastID, Version: s.Version, Answers: s.Answers}
	return s
}

// Reduce is the one place the wizard's state changes. It never edits the
// state it was given: Past is copied before it grows.
func Reduce(s State, a Action) State {
	at := snapshot{s.Step, s.Answers}
	past := append(append([]snapshot{}, s.Past...), at)
	if a.Type != "save-finished" {
		s.Error = ""
	}
	switch a.Type {
	case "edit":
		if s.Answers.get(a.Field) == a.Value {
			return s
		}
		s.Past = past
		s.Answers.set(a.Field, a.Value)
		s.Version++
	case "next":
		var gaps []string
		for _, f := range required[s.Step] {
			if strings.TrimSpace(s.Answers.get(f)) == "" {
				gaps = append(gaps, f)
			}
		}
		if len(gaps) > 0 {
			s.Error = "missing: " + strings.Join(gaps, ", ")
		} else if s.Step != "review" {
			s.Past = past
			s.Step = Steps[index(s.Step)+1]
		}
	case "back":
		if s.Step != "you" {
			s.Past = past
			s.Step = Steps[index(s.Step)-1]
		}
	case "undo":
		if len(s.Past) > 0 {
			last := s.Past[len(s.Past)-1]
			s.Past = s.Past[: len(s.Past)-1 : len(s.Past)-1]
			if last.Answers != s.Answers {
				s.Version++
			}
			s.Step, s.Answers = last.Step, last.Answers
		}
	case "reset":
		// Start over. A save already sent is forgotten here, not canceled on the server.
		s.Step, s.Answers, s.Past = "you", Answers{}, nil
		s.Version++
		s.Request, s.Queued, s.Failed = nil, false, false
	case "autosave":
		if s.Request != nil {
			s.Queued = true
		} else if s.Version != s.SavedVersion {
			s = send(s)
		}
	case "save-finished":
		// A reply for a save this state did not send is ignored, not trusted.
		if s.Request == nil || a.ID != s.Request.ID {
			return s
		}
		if a.OK {
			s.SavedVersion = s.Request.Version
			s.Failed = false
		} else {
			s.Failed = true
		}
		s.Request = nil
		if s.Queued && s.Version != s.SavedVersion {
			s = send(s)
		}
		s.Queued = false
	}
	return s
}

func Status(s State) string {
	switch {
	case s.Request != nil:
		return "saving"
	case s.Version == s.SavedVersion:
		return "saved"
	case s.Failed:
		return "failed"
	}
	return "unsaved"
}