Module boundaries.

// The folder names suggest boundaries, but these exports make every detail public.
export const sessionRows = rawSessions;
export const memberRows = rawMembers;

export function enrollDirect(sessionId: string, memberId: string): string | null {
	const session = sessionRows.find((item) => item.id === sessionId);
	const member = memberRows.find((item) => item.id === memberId);
	if (!session || !member || session.seatsLeft < 1) return null;
	session.seatsLeft -= 1;
	return `${member.name} · ${session.title}`;
}

type catalogModule struct{}

func NewCatalog() catalogModule { return catalogModule{} }

func (catalogModule) GetSession(id string) *SessionCard {
	for _, session := range rawSessions {
		if session.ID == id {
			card := session.SessionCard
			return &card
		}
	}
	return nil
}

// ReserveSeat is the only code that changes a seat count, because Catalog owns it.
func (catalogModule) ReserveSeat(id string) bool {
	for index := range rawSessions {
		if rawSessions[index].ID == id {
			if rawSessions[index].SeatsLeft < 1 {
				return false
			}
			rawSessions[index].SeatsLeft--
			return true
		}
	}
	return false
}

type membersModule struct{}

func NewMembers() membersModule { return membersModule{} }

func (membersModule) GetMember(id string) *MemberProfile {
	for _, member := range rawMembers {
		if member.ID == id {
			profile := member.MemberProfile
			return &profile
		}
	}
	return nil
}

type enrollmentModule struct {
	readSession func(string) *SessionCard
	readMember  func(string) *MemberProfile
	reserveSeat func(string) bool
	enrolled    map[string]enrollmentView
}

func NewEnrollment(readSession func(string) *SessionCard, readMember func(string) *MemberProfile, reserveSeat func(string) bool) enrollmentModule {
	return enrollmentModule{readSession: readSession, readMember: readMember, reserveSeat: reserveSeat, enrolled: map[string]enrollmentView{}}
}

func (module enrollmentModule) Enroll(sessionID, memberID string) enrollmentResult {
	key := sessionID + ":" + memberID
	if _, exists := module.enrolled[key]; exists {
		return enrollmentResult{Kind: "rejected", Reason: "already-enrolled"}
	}
	session := module.readSession(sessionID)
	if session == nil {
		return enrollmentResult{Kind: "rejected", Reason: "unknown-session"}
	}
	if session.SeatsLeft < 1 {
		return enrollmentResult{Kind: "rejected", Reason: "session-full"}
	}
	member := module.readMember(memberID)
	if member == nil {
		return enrollmentResult{Kind: "rejected", Reason: "unknown-member"}
	}
	if !module.reserveSeat(sessionID) {
		return enrollmentResult{Kind: "rejected", Reason: "session-full"}
	}
	receipt := enrollmentView{ConfirmationID: fmt.Sprintf("confirmation-%d", len(module.enrolled)+1), SessionTitle: session.Title, MemberName: member.Name}
	module.enrolled[key] = receipt
	return enrollmentResult{Kind: "enrolled", Receipt: &receipt}
}

func (module enrollmentModule) GetReceipt(sessionID, memberID string) *enrollmentView {
	receipt, exists := module.enrolled[sessionID+":"+memberID]
	if !exists {
		return nil
	}
	return &receipt
}

// The import rule an architecture test would enforce: each module lists what it may import.
export type ModuleName = 'web' | 'app' | 'enrollment' | 'catalog' | 'members';
export type ImportGraph = Readonly<Record<ModuleName, readonly ModuleName[]>>;

export const allowedImports: ImportGraph = {
	web: ['app'],
	app: ['enrollment', 'catalog', 'members'],
	enrollment: ['catalog', 'members'],
	catalog: [],
	members: []
};

export function checkImport(graph: ImportGraph, from: ModuleName, to: ModuleName) {
	return graph[from].includes(to) ? 'allowed' : 'blocked';
}

export function findCycle(graph: ImportGraph): ModuleName[] | null {
	const done = new Set<ModuleName>();
	const visit = (name: ModuleName, path: ModuleName[]): ModuleName[] | null => {
		if (path.includes(name)) return [...path.slice(path.indexOf(name)), name];
		if (done.has(name)) return null;
		for (const next of graph[name]) {
			const cycle = visit(next, [...path, name]);
			if (cycle) return cycle;
		}
		done.add(name);
		return null;
	};
	for (const name of Object.keys(graph) as ModuleName[]) {
		const cycle = visit(name, []);
		if (cycle) return cycle;
	}
	return null;
}

// The import rule an architecture test would enforce: each module lists what it may import.
type importGraph map[string][]string

var moduleOrder = []string{"web", "app", "enrollment", "catalog", "members"}

var allowedImports = importGraph{
	"web":        {"app"},
	"app":        {"enrollment", "catalog", "members"},
	"enrollment": {"catalog", "members"},
	"catalog":    {},
	"members":    {},
}

func checkImport(graph importGraph, from, to string) string {
	if slices.Contains(graph[from], to) {
		return "allowed"
	}
	return "blocked"
}

func findCycle(graph importGraph) []string {
	done := map[string]bool{}
	var visit func(name string, path []string) []string
	visit = func(name string, path []string) []string {
		if at := slices.Index(path, name); at >= 0 {
			return append(slices.Clone(path[at:]), name)
		}
		if done[name] {
			return nil
		}
		for _, next := range graph[name] {
			if cycle := visit(next, append(slices.Clone(path), name)); cycle != nil {
				return cycle
			}
		}
		done[name] = true
		return nil
	}
	for _, name := range moduleOrder {
		if cycle := visit(name, nil); cycle != nil {
			return cycle
		}
	}
	return nil
}

func withImport(graph importGraph, from, to string) importGraph {
	next := importGraph{}
	for name, imports := range graph {
		next[name] = slices.Clone(imports)
	}
	next[from] = append(next[from], to)
	return next
}