/* Copyright (C) 2019  C. McEnroe <june@causal.agency>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <SDL.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

#include "cards.h"
#include "stack.h"

typedef unsigned uint;

enum {
	Stock,
	Waste1,
	Waste3,
	Foundation1,
	Foundation2,
	Foundation3,
	Foundation4,
	Tableau1,
	Tableau2,
	Tableau3,
	Tableau4,
	Tableau5,
	Tableau6,
	Tableau7,
	StacksLen,
};

static struct Stack stacks[StacksLen];

static void restock(void) {
	for (uint i = 0; i < StacksLen; ++i) {
		stackClear(&stacks[i]);
	}
	stackDeck(&stacks[Stock]);
}

static void reveal(uint i) {
	if (!stacks[i].len) return;
	stackPush(&stacks[i], abs(stackPop(&stacks[i])));
}

static void deal(void) {
	stackShuffle(&stacks[Stock]);
	for (uint i = Tableau1; i <= Tableau7; ++i) {
		stackMoveTo(&stacks[i], &stacks[Stock], 1 + i - Tableau1);
		reveal(i);
	}
}

static void draw(void) {
	stackMoveTo(&stacks[Waste1], &stacks[Waste3], stacks[Waste3].len);
	if (stacks[Stock].len) {
		stackFlipTo(&stacks[Waste3], &stacks[Stock], 3);
	} else {
		stackFlipTo(&stacks[Stock], &stacks[Waste1], stacks[Waste1].len);
	}
}

enum {
	StackMarginX = 11,
	StackMarginY = 6,

	StockX = StackMarginX,
	StockY = StackMarginY,

	WasteX = StockX + Cards_Width + StackMarginX,
	WasteY = StackMarginY,

	FoundationX = WasteX + 2 * (Cards_Width + StackMarginX),
	FoundationY = StackMarginY,

	TableauX = StackMarginX,
	TableauY = StockY + Cards_Height + StackMarginY,

	StackDeltaX = 2,
	StackDeltaY = 1,

	Waste3DeltaX = 14,
	Waste3DeltaY = StackDeltaY,

	TableauDeltaX = 0,
	TableauDeltaYBack = 3,
	TableauDeltaYFront = 15,

	WindowWidth = 7 * Cards_Width + 8 * StackMarginX,
	WindowHeight = 2 * (StackMarginY + Cards_Height)
		+ 6 * TableauDeltaYBack
		+ 12 * TableauDeltaYFront
		+ StackMarginY,
};

struct Item {
	SDL_Rect rect;
	uint tex;
	Sint8 card;
};

struct Layout {
	uint len;
	struct Item items[52];
};

static void layoutClear(struct Layout *list) {
	list->len = 0;
}
static void layoutPush(struct Layout *list, struct Item item) {
	assert(list->len < 52);
	list->items[list->len++] = item;
}

static struct {
	struct Layout base;
	struct Layout main;
	struct Layout drag;
	struct Item dragItem;
} layout;

static uint cardBack = Cards_Back1;

static void layoutCard(struct Layout **list, SDL_Rect *rect, Sint8 card) {
	if (card == layout.dragItem.card) {
		*list = &layout.drag;
		*rect = layout.dragItem.rect;
	}
	struct Item item = { *rect, (card > 0 ? card : cardBack), card };
	layoutPush(*list, item);
}

static void layoutStack(SDL_Rect *rect, const struct Stack *stack, uint depth) {
	struct Layout *list = &layout.main;
	for (uint i = 0; i < stack->len; ++i) {
		layoutCard(&list, rect, stack->cards[i]);
		if (i > 0 && i % (depth / 3) == 0) {
			rect->x += StackDeltaX;
			rect->y += StackDeltaY;
		}
	}
}

static void layoutStock(void) {
	SDL_Rect rect = { StockX, StockY, Cards_Width, Cards_Height };
	struct Item item = { rect, Cards_O, 0 };
	layoutPush(&layout.base, item);
	layoutStack(&rect, &stacks[Stock], 24);
}

static void layoutWaste(void) {
	SDL_Rect rect = { WasteX, WasteY, Cards_Width, Cards_Height };
	layoutStack(&rect, &stacks[Waste1], 24);
	struct Layout *list = &layout.main;
	for (uint i = 0; i < stacks[Waste3].len; ++i) {
		layoutCard(&list, &rect, stacks[Waste3].cards[i]);
		rect.x += Waste3DeltaX;
		rect.y += Waste3DeltaY;
	}
}

static void layoutFoundations(void) {
	SDL_Rect base = { FoundationX, FoundationY, Cards_Width, Cards_Height };
	for (uint i = Foundation1; i <= Foundation4; ++i) {
		struct Item item = { base, Cards_Empty, 0 };
		layoutPush(&layout.base, item);
		SDL_Rect rect = base;
		layoutStack(&rect, &stacks[i], 13);
		base.x += Cards_Width + StackMarginX;
	}
}

static void layoutTableau(void) {
	SDL_Rect base = { TableauX, TableauY, Cards_Width, Cards_Height };
	for (uint i = Tableau1; i <= Tableau7; ++i) {
		struct Layout *list = &layout.main;
		SDL_Rect rect = base;
		for (uint j = 0; j < stacks[i].len; ++j) {
			Sint8 card = stacks[i].cards[j];
			layoutCard(&list, &rect, card);
			rect.x += TableauDeltaX;
			rect.y += (card > 0 ? TableauDeltaYFront : TableauDeltaYBack);
		}
		base.x += Cards_Width + StackMarginX;
	}
}

static SDL_Renderer *render;
static SDL_Texture *textures[Cards_Count];

static void renderLayout(const struct Layout *list) {
	for (uint i = 0; i < list->len; ++i) {
		SDL_RenderCopy(
			render,
			textures[list->items[i].tex],
			NULL, &list->items[i].rect
		);
	}
}

static void err(const char *prefix) {
	fprintf(stderr, "%s: %s\n", prefix, SDL_GetError());
	exit(EXIT_FAILURE);
}

int main(void) {
	if (SDL_Init(SDL_INIT_VIDEO) < 0) err("SDL_Init");
	atexit(SDL_Quit);

	SDL_Window *window;
	int error = SDL_CreateWindowAndRenderer(
		WindowWidth, WindowHeight, SDL_WINDOW_ALLOW_HIGHDPI,
		&window, &render
	);
	if (error) err("SDL_CreateWindowAndRenderer");

	SDL_SetWindowTitle(window, "Solitaire");

	int width, height;
	SDL_GetRendererOutputSize(render, &width, &height);
	if (width > WindowWidth && height > WindowHeight) {
		SDL_RenderSetIntegerScale(render, SDL_TRUE);
		SDL_RenderSetScale(
			render,
			(float)width / WindowWidth,
			(float)height / WindowHeight
		);
	}

	// TODO: Path search/option.
	SDL_RWops *rw = SDL_RWFromFile("CARDS.DLL", "rb");
	if (!rw) err("CARDS.DLL");

	struct Cards *cards = Cards_Load(
		rw, Cards_ColorKey | Cards_AlphaCorners | Cards_BlackBorders
	);
	if (!cards) err("Cards_Load");
	SDL_RWclose(rw);

	for (uint i = 0; i < Cards_Count; ++i) {
		textures[i] = NULL;
		if (!cards->surfaces[i]) continue;
		textures[i] = SDL_CreateTextureFromSurface(render, cards->surfaces[i]);
		if (!textures[i]) err("SDL_CreateTextureFromSurface");
	}
	Cards_Free(cards);

	restock();
	deal();

	for (;;) {
		SDL_Event event;
		SDL_WaitEvent(&event);
		if (event.type == SDL_QUIT) goto quit;

		if (event.type == SDL_KEYDOWN) {
			switch (event.key.keysym.sym) {
				break; case SDLK_q: goto quit;
				break; case SDLK_r: restock(); deal();
				break; case SDLK_SPACE: draw();
				break; case SDLK_f: {
					stackFlipTo(&stacks[Foundation1], &stacks[Stock], 1);
				}
				break; case SDLK_t: {
					stackFlipTo(&stacks[Tableau7], &stacks[Stock], 1);
				}
				break; case SDLK_b: {
					cardBack = Cards_Back1 + (cardBack - Cards_Back1 + 1) % 12;
				}
			}
		}

		if (event.type == SDL_MOUSEBUTTONDOWN) {
			struct SDL_Point point = { event.button.x, event.button.y };
			for (uint i = layout.main.len - 1; i < layout.main.len; --i) {
				if (SDL_PointInRect(&point, &layout.main.items[i].rect)) {
					layout.dragItem = layout.main.items[i];
					break;
				}
			}
		}

		if (event.type == SDL_MOUSEBUTTONUP) {
			layout.dragItem.card = 0;
		}

		if (event.type == SDL_MOUSEMOTION && event.motion.state) {
			layout.dragItem.rect.x += event.motion.xrel;
			layout.dragItem.rect.y += event.motion.yrel;
		}

		layoutClear(&layout.base);
		layoutClear(&layout.main);
		layoutClear(&layout.drag);

		layoutStock();
		layoutWaste();
		layoutFoundations();
		layoutTableau();

		SDL_SetRenderDrawColor(render, 0x00, 0xAA, 0x55, 0xFF);
		SDL_RenderClear(render);

		renderLayout(&layout.base);
		renderLayout(&layout.main);
		renderLayout(&layout.drag);

		SDL_RenderPresent(render);
	}

quit:
	SDL_Quit();
}