// SPDX-License-Identifier: MIT

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include "util.h"
#include "net.h"
#include "ha.h"
#include "list.h"
#include "slider.h"
#include "preferences.h"
#include "entity_ldef.h"

#define kScrollBarWidth 15
#define kSliderCDEFId 128
#define kEntityLDEFId 128
#define kCustomSliderProc (16 * kSliderCDEFId)
#define kCustomListProc (kEntityLDEFId)
#define kBarUpdateRate (1 * 60) // 1 second(s)
#define kBarWidth 100
#define kCtrlWidth 40
#define kCtrlHeight 80
#define kCtrlPad ((kBarWidth - kCtrlWidth) / 2)

#define kEntityListDialog 128

#define mApple 128
#define mFile 129
#define mEdit 130

#define miAbout 1
#define miEntityAdd 1
#define miQuit 3
#define miClear 4

/* GLOBALS */
Boolean gRunning = true;
short gNumBars = 0;
Boolean gHaveScrollBar = false;

Handle gSliderCDEF, gEntityLDEF;
PrefHandle gPreferences;
MenuHandle gEditMenu;

Pattern gSliderPattern, gBackPattern;

WindowPtr gMainWindow = NULL;
list_t gEntities = LIST_INIT(gEntities);

/* PROTOTYPES */
void ensure_valid_prefs(void);
void dialog_info_free(struct dialog_info *dinfo);
void entity_list_add(struct dialog_info *dinfo);
void entity_list_mousedown(EventRecord* evt, WindowPtr win);
void entity_list_activate(bool activate, WindowPtr win);
void entity_list_show(void);
void event_loop(void);
void event_update(WindowPtr win);
void event_activate(bool activate, EventRecord* evt, WindowPtr win);
void event_mousedown(EventRecord*, WindowPtr, short);

void menu_init(void);
void menu_click(long);

void lightsout_init(Handle previousEnts);
void bar_create(WindowPtr win, const char* id);

void resolve_slider_cdef();
void resolve_entity_ldef();

pascal void dialog_list_update(WindowPtr theWin, short itemNo);

void bar_draw(struct entity*);
void bars_draw();
void draw_background();
void bars_update();

void scrollbar_create(WindowPtr win);
void scrollbar_remove(WindowPtr win);

void update_entity_positions(short scrollValue);
void get_entity_bounds(struct entity *ent, Rect* out);

struct dialog_info
{
	ListHandle lHnd;
	struct list ents;
	void (*handle_mousedown)(EventRecord*, WindowPtr);
	void (*handle_activate)(bool activate, WindowPtr);
};

struct window_info
{
	ControlHandle scrollBar;
};

enum control_type
{
	CONTROL_SLIDER,
	CONTROL_SCROLLBAR,
};

void ensure_valid_prefs(void)
{
	bool updatedPrefs = false;
	
	gPreferences = preferences_load();
	
	while (ha_test_prefs() != 0)
	{
		info("Server configuration is invalid; "
			 "please review your settings.");

		// preferences invalid; show preferences dialog
		if (preferences_dialog() != 0)
		{
			ExitToShell();
		} else {
			updatedPrefs = true;
		}
	}
	
	if (updatedPrefs)
		preferences_save(gPreferences);
}

int main()
{	
	toolbox_init();
	memory_init();
	net_init();

	resolve_slider_cdef();
	resolve_entity_ldef();
	GetIndPattern(&gSliderPattern, 0, 22);
	GetIndPattern(&gBackPattern, 0, 3);
	
	menu_init();
	
	ensure_valid_prefs();
	
	lightsout_init(preferences_get_entities());
	event_loop();
	
	net_fini();
	
	preferences_save_entities(&gEntities);
	
	return 0;
}

void resolve_slider_cdef()
{
	def_jmp_t* slider_cdef;
	gSliderCDEF = GetResource('CDEF', 128);
	HLock(gSliderCDEF);
	
	slider_cdef = (def_jmp_t*)*gSliderCDEF;
	slider_cdef->addr = slider_proc;
}

void resolve_entity_ldef()
{
	def_jmp_t* entity_ldef;
	gEntityLDEF = GetResource('LDEF', 128);
	HLock(gEntityLDEF);
	
	entity_ldef = (def_jmp_t*)*gEntityLDEF;
	entity_ldef->addr = entity_ldef_proc;
}

void scrollbar_create(WindowPtr win)
{
	struct window_info *info = (void*)GetWRefCon(win);
	Rect sbRect;
	short winHeight = rect_height(&win->portRect);
	short winWidth = rect_width(&win->portRect);
	
	sbRect.top = winHeight - kScrollBarWidth;
	sbRect.left = -1;
	sbRect.right = winWidth + 1;
	sbRect.bottom = winHeight + 1;
	
	info->scrollBar = NewControl(win,
		&sbRect,
		(u8*)"",
		true,
		0,
		0,
		1,
		scrollBarProc,
		CONTROL_SCROLLBAR);
}

void scrollbar_remove(WindowPtr win)
{
	struct window_info *info = (void*)GetWRefCon(win);
	
	if (info->scrollBar)
	{
		DisposeControl(info->scrollBar);
		info->scrollBar = NULL;
	}
}

void handle_scrollbar(WindowPtr win)
{
	short width = rect_width(&win->portRect);
	short height = rect_height(&win->portRect);
	if (gNumBars > 3 && !gHaveScrollBar)
	{
		SizeWindow(win, width, height + kScrollBarWidth, true);
		scrollbar_create(win);
		gHaveScrollBar = true;
	} else if (gNumBars > 3)
	{
		struct window_info *info = (void*)GetWRefCon(win);
		SetControlMaximum(info->scrollBar, gNumBars - 3);
	}
	
	if (gNumBars <= 3 && gHaveScrollBar)
	{
		SizeWindow(win, width, height - kScrollBarWidth, true);
		scrollbar_remove(win);
		gHaveScrollBar = false;
	}
}

void bar_create(WindowPtr win, const char* id)
{
	struct entity* ent = xmalloc(sizeof(struct entity));
	Rect controlPos;
	Rect updateBounds;
	
	short winHeight;
	short barOffset = gNumBars * kBarWidth;
	
	snprintf(ent->id, 128, "%s", id);
	
	winHeight = rect_height(&win->portRect);
	winHeight -= (gHaveScrollBar ? kScrollBarWidth : 0);
	
	controlPos.top = (winHeight - kCtrlHeight)/2;
	controlPos.bottom = controlPos.top + kCtrlHeight;
	controlPos.left = barOffset + kCtrlPad;
	controlPos.right = controlPos.left + kCtrlWidth;
	
	ha_get_entity_state(ent->id, &ent->state);
	
	ent->ctrl = NewControl(
		win,
		&controlPos,
		nil,
		true,
		ent->state.brightness, // current value
		0, 255,
		kCustomSliderProc,
		CONTROL_SLIDER
	);
	
	ent->outerRgn = NewRgn();
	ent->selected = false;
	
	get_entity_bounds(ent, &updateBounds);
	
	updateBounds.right += 2; // bg edge
	
	list_add_tail(&gEntities, &ent->node);
	
	gNumBars++;
	
	barOffset += kBarWidth;
	
	handle_scrollbar(win);

	with_port(win, {
		InvalRect(&updateBounds);
	})
}

void bar_remove(WindowPtr win, struct entity *ent)
{
	struct window_info *info = (void*)GetWRefCon(win);
	short scrollValue = 0;
	Rect barRect;
	
	get_entity_bounds(ent, &barRect);
	
	list_del(&ent->node);
	DisposeControl(ent->ctrl);
	DisposeRgn(ent->outerRgn);
	free(ent);
	
	// you can't just update the bar rect,
	// because other bars might shift into the window area
	with_port(win, {
		InvalRect(&win->portRect);
	})
	
	gNumBars--;
	
	handle_scrollbar(win);

	if (info->scrollBar)
		scrollValue = GetControlValue(info->scrollBar);	

	update_entity_positions(scrollValue);
}

/** Update a list in a dialog.
 *
 * Assumes the list is stored in the window reference of the
 * dialog. Then calls LUpdate to update the list contents,
 * and FrameRect to draw the border around the list.
 */
pascal void dialog_list_update(WindowPtr theWin, short itemNo)
{
	struct dialog_info *dinfo = (void*)GetWRefCon(theWin);
	ListHandle lHnd = dinfo->lHnd;
	Rect frameRect = (**lHnd).rView;
	frameRect.right += kScrollBarWidth;
	rect_expand(&frameRect, 1);
	
	LUpdate(theWin->visRgn, lHnd);
	
	FrameRect(&frameRect);
}

void dialog_info_free(struct dialog_info *dinfo)
{
	list_t *node;
	LDispose(dinfo->lHnd);
	
	while ((node = list_pop(&dinfo->ents)) != NULL)
	{
		free(container_of(node, struct entity, node));
	}
	
	free(dinfo);
}

void entity_list_add(struct dialog_info* dinfo)
{
	Point pt = {0, 0};
	struct entity* ent;
	if (LGetSelect(true, &pt, dinfo->lHnd))
	{
		short len = 4;
		LGetCell(&ent, &len, pt, dinfo->lHnd);
		bar_create(gMainWindow, ent->id);
	}
}

void entity_list_mousedown(EventRecord* evt, WindowPtr win)
{
	DialogPtr theDialog;
	short itemHit;
	struct dialog_info* dinfo = (void*)GetWRefCon(win);
	
	with_port(win, {
		DialogSelect(evt, &theDialog, &itemHit);

		GlobalToLocal(&evt->where);
		
		switch (itemHit)
		{
		case 1:
			entity_list_add(dinfo);
			
			// must dispose of list before dialog
			dialog_info_free(dinfo);
			DisposeDialog(theDialog);
			break;
		case 2:
			LClick(evt->where, evt->modifiers, dinfo->lHnd);
			break;
		}
	})
}

void entity_list_activate(bool activate, WindowPtr win)
{
	struct dialog_info *dinfo = (void*)GetWRefCon(win);
	LActivate(activate, dinfo->lHnd);
}

/* Open the entity selection dialog. */
void entity_list_show()
{
	short type;
	Handle itemHnd;
	Rect itemRect, contentRect;
	Rect dataBounds;
	Point cSize = {0, 0};
	Point pt = {0, 0};
	ListHandle lHnd;
	struct dialog_info *dinfo = xmalloc(sizeof(struct dialog_info));
	struct entity *ent;
	list_t *node;
	
	short numEnts = ha_get_entities(&dinfo->ents);
	
	DialogPtr dlog = GetNewDialog(
		kEntityListDialog, nil, (WindowPtr)-1);

	GetDialogItem(dlog, 2, &type, &itemHnd, &itemRect);
	SetDialogItem(dlog, 2, type, (Handle)dialog_list_update, &itemRect);
	
	contentRect = itemRect;
	contentRect.right -= kScrollBarWidth;
	
	rect_expand(&itemRect, 1);
	
	SetRect(&dataBounds, 0, 0, 1, 0);
	lHnd = LNew(&contentRect, &dataBounds, cSize, kCustomListProc,
		dlog, true, false, false, true);
	
	// todo allow multiple selections
	(**lHnd).selFlags |= lOnlyOne;
	
	dinfo->lHnd = lHnd;
	dinfo->handle_mousedown = entity_list_mousedown;
	dinfo->handle_activate = entity_list_activate;
	
	SetWRefCon(dlog, (long)dinfo);

	LAddRow(numEnts, 0, lHnd);
	
	list_foreach(&dinfo->ents, node)
	{
		ent = container_of(node, struct entity, node);
		LSetCell(&ent, sizeof(Ptr), pt, lHnd);
		pt.v++;
	}
	
	ShowWindow(dlog);
}

void lightsout_init(Handle previousEnts)
{
	WindowPtr win;
	short controlWidth = 40;
	short controlHeight = 80;
	struct window_info *wi = xmalloc(sizeof(struct window_info));

	win = GetNewCWindow(128, nil, (WindowPtr)-1);
	SetWTitle(win, "\pLights Out");
	SetWRefCon(win, (long)wi);
	
	wi->scrollBar = NULL;
	
	SetPort(win);

	win_center(win);

	gMainWindow = win;

	if (previousEnts)
	{
		// previous entities are packed into the handle
		// as consecutive NUL-terminated strings.
		size_t sz = GetHandleSize(previousEnts);
		size_t idx = 0;
		size_t len = 0;
		HLock(previousEnts);
		
		while (idx < sz)
		{
			len = strlen(*previousEnts + idx);
			bar_create(win, *previousEnts + idx);
			idx += len + 1;
		}
		
		HUnlock(previousEnts);
	}
	
	ShowWindow(win);
}

void menu_init(void)
{
	Handle menuBar = GetNewMBar(128);
	MenuHandle appleMenu;
	short i;
	
	SetMenuBar(menuBar);
	
	gEditMenu = GetMenuHandle(mEdit);
	
	for (i = 1; i <= miClear; ++i)
		DisableItem(gEditMenu, i);

	appleMenu = GetMenuHandle(mApple);
	AppendResMenu(appleMenu, 'DRVR');

	DrawMenuBar();
}

bool menu_item_enabled(MenuHandle hnd, short itemId)
{
	if (itemId < 32)
	{
		return (**hnd).enableFlags & (1 << itemId);
	}
	return (**hnd).enableFlags & 1;
}

void menu_update()
{
	struct entity *ent;
	list_t *node;
	bool any_selected = false;
	bool itemEnabled = menu_item_enabled(gEditMenu, miClear);
	
	list_foreach(&gEntities, node)
	{
		ent = container_of(node, struct entity, node);
		if (ent->selected)
			any_selected = true;
	}
	
	if (any_selected && !itemEnabled)
	{
		EnableItem(gEditMenu, miClear);
	}
	else if (!any_selected && itemEnabled)
	{
		DisableItem(gEditMenu, miClear);
	}
}

void menu_click(long menuChoice)
{
	short menuId, itemId;
	MenuHandle theMenu;
	GrafPtr oldPort;
	Str255 itemName;
	menuId = HiWord(menuChoice);
	itemId = LoWord(menuChoice);
	
	switch (menuId)
	{
		case mApple:
			if (itemId == miAbout)
			{
				info("LightsOut\r© 2025 Sam van Kampen");
			} else
			{
				theMenu = GetMenuHandle(menuId);
				GetMenuItemText(theMenu, itemId, itemName);
				GetPort(&oldPort);
				OpenDeskAcc(itemName);
				SetPort(oldPort);
			}
			break;
		case mFile:
			if (itemId == miEntityAdd)
			{
				entity_list_show();
			}
			else if (itemId == miQuit)
			{
				gRunning = false;
			}
			break;
		case mEdit:
			if (itemId == miClear && FrontWindow() == gMainWindow)
			{
				struct entity *ent;
				list_t *node, *prev;
				list_foreach_safe_rev(&gEntities, node, prev)
				{
					ent = container_of(node, struct entity, node);
					if (ent->selected)
						bar_remove(gMainWindow, ent);
				}
			}
			break;
	}
	
	HiliteMenu(0);
}

void get_entity_bounds(struct entity *ent, Rect* out)
{
	Rect* sliderBounds;
	short scrollBarCompensation = (gHaveScrollBar ? kScrollBarWidth : 0);
	WindowPtr win = (**(ent->ctrl)).contrlOwner;
	
	HLock((Handle)ent->ctrl);
	sliderBounds = &(*(ent->ctrl))->contrlRect;
	HUnlock((Handle)ent->ctrl);
	
	SetRect(out, sliderBounds->left - kCtrlPad,
		0, sliderBounds->right + kCtrlPad,
		win->portRect.bottom - scrollBarCompensation);
}

void bar_draw(struct entity *ent)
{
	ControlHandle ctrl = ent->ctrl;
	char buf[128];
	unsigned char* pBuf;
	Rect sliderBounds = (*ctrl)->contrlRect;
	Rect barBounds;
	short width;
	short val = GetControlValue(ctrl);
	
	TextFont(1);
	TextSize(10);
	
	get_entity_bounds(ent, &barBounds);

	EraseRect(&barBounds);
	FrameRect(&barBounds);
	
	snprintf(buf, 128, "%d%%",
		(val * 100 + 127) / 255);
		
	pBuf = c2pstr(buf);
	width = StringWidth(pBuf);
	
	MoveTo(barBounds.left + (kBarWidth - width)/2,
		sliderBounds.bottom + 20);
	
	DrawString(pBuf);

	strcpy(buf, ent->state.name);
	pBuf = c2pstr(buf);
	width = StringWidth(pBuf);
	
	MoveTo(barBounds.left + (kBarWidth - width) / 2,
		sliderBounds.top - 10);
	
	DrawString(pBuf);
	
	SetRectRgn(ent->outerRgn, 0, 0, 0, 0);
	
	OpenRgn();
	FrameRect(&barBounds);
	FrameRoundRect(&sliderBounds, 15, 15);
	CloseRgn(ent->outerRgn);
	
	if (ent->selected)
	{
		InvertRect(&barBounds);
	}
}

void bars_draw()
{
	list_t *node;
	struct entity *ent;
	
	list_foreach(&gEntities, node)
	{
		ent = container_of(node, struct entity, node);
		
		bar_draw(ent);
	}
}

void bars_update()
{
	struct entity *ent;
	list_t *node;
	static uint32_t lastTickCount = 0;
	WindowPeek win = (WindowPeek)gMainWindow;
	short val;
	bool changed = false;
	
	if (lastTickCount + kBarUpdateRate > TickCount())
		return;

	list_foreach(&gEntities, node)
	{
		ent = container_of(node, struct entity, node);
		val = GetControlValue(ent->ctrl);
		ha_get_entity_state(ent->id, &ent->state);
		
		if (ent->state.brightness != val)
		{
			SetControlValue(ent->ctrl, ent->state.brightness);
			changed = true;
		}
	}
	
	if (changed)
	{
		with_port(gMainWindow, {
			InvalRect(&gMainWindow->portRect);
		})
	}
	
	lastTickCount = TickCount();
}

void draw_background(WindowPtr win)
{
	Rect drawRect;
	short height = rect_height(&win->portRect);
	short width = rect_width(&win->portRect);
	short offset = kBarWidth * gNumBars;
	if (offset > width)
		return;
	
	SetRect(&drawRect, offset, 0, width, height);
	
	FillRect(&drawRect, &gBackPattern);
	FrameRect(&drawRect);
}

struct entity *entity_for_control(ControlHandle hnd)
{
	struct entity *ent;
	list_t *node;
	
	list_foreach(&gEntities, node)
	{
		ent = container_of(node, struct entity, node);
		if (ent->ctrl == hnd)
			return ent;
	}
	
	return NULL;
}

void event_update(WindowPtr win)
{
	WindowPeek wPeek = (WindowPeek)win;
	
	with_port(win, {
		if (win == gMainWindow)
		{
			bars_draw();
			draw_background(win);
			UpdateControls(win, win->visRgn);
		}
	})
}

void update_entity_positions(short scrollValue)
{
	struct entity *ent;
	list_t *node;
	Rect curPos;
	short i = 0;
	
	list_foreach(&gEntities, node)
	{
		ent = container_of(node, struct entity, node);
		curPos = (**(ent->ctrl)).contrlRect;
		MoveControl(ent->ctrl,
			(i - scrollValue) * kBarWidth + kCtrlPad,
			curPos.top);
		
		i++;	
	}
}

void
control_mousedown(WindowPtr win, EventRecord* evt,
				  ControlHandle ctrl, short part)
{
	short orig_val = GetControlValue(ctrl);
	if (part = TrackControl(ctrl, evt->where, nil))
	{
		long ref = GetControlReference(ctrl);
		switch (ref)
		{
		case CONTROL_SLIDER:
		{
			struct entity *ent = entity_for_control(ctrl);
			short val = GetControlValue(ctrl);
			InvalRect(&win->portRect);
			ent->state.brightness = val;
			ha_set_entity_state(ent->id, &ent->state);
			break;
		}
		case CONTROL_SCROLLBAR:
		{
			short val = orig_val;
			short max = GetControlMaximum(ctrl);
				
			switch (part)
			{
			case inPageUp: // left gray
			case inUpButton: // left
				val = MAX(0, val - 1);
				break;
			case inPageDown: // right gray
			case inDownButton: // right
				val = MIN(max, val + 1);
				break;
			case inThumb:
				// control manager calculates new value for us
				val = GetControlValue(ctrl);
				break;
			}
			SetControlValue(ctrl, val);
			
			if (val != orig_val)
			{
				update_entity_positions(val);
				InvalRect(&win->portRect);
			}
			break;
		}
		}
	}
}

struct entity* find_entity_for_click(WindowPtr win, Point where)
{
	struct entity *ent;
	list_t *node;

	if (win != gMainWindow)
		return NULL;
	
	list_foreach(&gEntities, node)
	{
		ent = container_of(node, struct entity, node);
		if (PtInRgn(where, ent->outerRgn))
			return ent;
	}
	
	return NULL;
}

void
event_mousedown(EventRecord* evt, WindowPtr win, short inPart)
{
	WindowPtr frontWin = FrontWindow();
	ControlHandle ctrl;
	short inCtrlPart;
	long menuChoice;
	
	if (win_is_dialog(frontWin) && win != frontWin)
	{
		SysBeep(20);
		return;
	}
	
	switch (inPart)
	{
	case inGoAway:
		break;
	case inMenuBar:
		menuChoice = MenuSelect(evt->where);
		if (menuChoice > 0)
			menu_click(menuChoice);
		break;
	case inContent:
		if (win_is_dialog(win))
		{
			struct dialog_info* dinfo = (void*)GetWRefCon(win);
			dinfo->handle_mousedown(evt, win);
		} else {
			struct entity* ent;
			GlobalToLocal(&evt->where);
			inCtrlPart = FindControl(evt->where, win, &ctrl);
			if (inCtrlPart)
			{
				control_mousedown(win, evt, ctrl, inCtrlPart);
			}
			
			if ((ent = find_entity_for_click(win, evt->where)))
			{
				Rect entityBounds;
				ent->selected = !ent->selected;
				get_entity_bounds(ent, &entityBounds);
				InvalRect(&entityBounds);
			}
		}
		break;
	case inDrag:
		DragWindow(win, evt->where, &qd.screenBits.bounds);
		break;
	case inSysWindow:
		SystemClick(evt, win);
		break;
	default:
		break;
	}
}

void event_activate(bool activate, EventRecord* evt, WindowPtr win)
{
	short junk;
	if (win_is_dialog(win))
	{
		struct dialog_info* dinfo = (void*)GetWRefCon(win);
		DialogSelect(evt, &(DialogPtr)win, &junk);
		dinfo->handle_activate(activate, win);
	}
}				

void event_loop()
{
	EventRecord event;
	WindowPtr win;
	
	short theChar;
	short junk;
	short inPart;
	
	while (gRunning)
	{
		if (WaitNextEvent(everyEvent, &event, 60L, nil))
		{	
			switch(event.what)
			{
			case mouseDown:
			{
				inPart = FindWindow(event.where, &win);
				with_port(win, {
					event_mousedown(&event, win, inPart);
				})
				break;
			}
			case updateEvt:
				win = (WindowPtr)event.message;
				if (win_is_dialog(win))
				{
					DialogSelect(&event, &(DialogPtr)win, &junk);
				} else {
					BeginUpdate(win);
					event_update(win);
					EndUpdate(win);
				}
				break;
			case keyDown:
			case autoKey:
				theChar = event.message & charCodeMask;
				if (event.modifiers & cmdKey)
					menu_click(MenuKey(theChar));
				break;
			case activateEvt:
			{
				bool activate = event.modifiers & 1;
				win = (WindowPtr)event.message;
				event_activate(activate, &event, win);
				break;
			}
			case osEvt:
				if ((event.message >> 24) == suspendResumeMessage)
				{
					bool activate = event.message & 1;
					win = FrontWindow();
					event_activate(activate, &event, win);
				}
				break;
			default:
				break;
			}
		} else {
			menu_update();
			bars_update();
		}
	}
}