import { resolve } from "node:path";
import { defineConfig } from "vite";
import wasm from "vite-plugin-wasm";

export default defineConfig({
	root: "website",
	plugins: [
		wasm(),
		// Build service worker as a separate, unhashed JS file
		{
			name: "build-sw",
			apply: "build",
			closeBundle: {
				sequential: true,
				async handler() {
					const { build } = await import("vite");
					await build({
						configFile: false,
						root: resolve(__dirname, "website"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist"),
							lib: {
								entry: resolve(__dirname, "website/sw.ts"),
								formats: ["es"],
								fileName: () => "sw.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "sw.js",
								},
							},
						},
					});

					// Build shell.ts as a standalone JS bundle
					await build({
						configFile: false,
						root: resolve(__dirname, "website"),
						resolve: {
							alias: {
								"@lib": resolve(__dirname, "./lib"),
								"@shared": resolve(__dirname, "./shared"),
							},
						},
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist"),
							lib: {
								entry: resolve(__dirname, "website/shell.ts"),
								formats: ["es"],
								fileName: () => "shell.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "shell.js",
								},
							},
						},
					});

					// Build books module components
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/books/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/books"),
							lib: {
								entry: resolve(__dirname, "modules/books/components/folk-book-shelf.ts"),
								formats: ["es"],
								fileName: () => "folk-book-shelf.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-book-shelf.js",
								},
							},
						},
					});

					await build({
						configFile: false,
						root: resolve(__dirname, "modules/books/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/books"),
							lib: {
								entry: resolve(__dirname, "modules/books/components/folk-book-reader.ts"),
								formats: ["es"],
								fileName: () => "folk-book-reader.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-book-reader.js",
								},
							},
						},
					});

					// Copy books CSS
					const { copyFileSync, mkdirSync } = await import("node:fs");
					mkdirSync(resolve(__dirname, "dist/modules/books"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/books/components/books.css"),
						resolve(__dirname, "dist/modules/books/books.css"),
					);

					// Build pubs module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/pubs/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/pubs"),
							lib: {
								entry: resolve(__dirname, "modules/pubs/components/folk-pubs-editor.ts"),
								formats: ["es"],
								fileName: () => "folk-pubs-editor.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-pubs-editor.js",
								},
							},
						},
					});

					// Copy pubs CSS
					mkdirSync(resolve(__dirname, "dist/modules/pubs"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/pubs/components/pubs.css"),
						resolve(__dirname, "dist/modules/pubs/pubs.css"),
					);

					// Build cart module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/cart/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/cart"),
							lib: {
								entry: resolve(__dirname, "modules/cart/components/folk-cart-shop.ts"),
								formats: ["es"],
								fileName: () => "folk-cart-shop.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-cart-shop.js",
								},
							},
						},
					});

					// Copy cart CSS
					mkdirSync(resolve(__dirname, "dist/modules/cart"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/cart/components/cart.css"),
						resolve(__dirname, "dist/modules/cart/cart.css"),
					);

					// Build providers module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/providers/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/providers"),
							lib: {
								entry: resolve(__dirname, "modules/providers/components/folk-provider-directory.ts"),
								formats: ["es"],
								fileName: () => "folk-provider-directory.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-provider-directory.js",
								},
							},
						},
					});

					// Copy providers CSS
					mkdirSync(resolve(__dirname, "dist/modules/providers"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/providers/components/providers.css"),
						resolve(__dirname, "dist/modules/providers/providers.css"),
					);

					// Build swag module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/swag/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/swag"),
							lib: {
								entry: resolve(__dirname, "modules/swag/components/folk-swag-designer.ts"),
								formats: ["es"],
								fileName: () => "folk-swag-designer.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-swag-designer.js",
								},
							},
						},
					});

					// Copy swag CSS
					mkdirSync(resolve(__dirname, "dist/modules/swag"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/swag/components/swag.css"),
						resolve(__dirname, "dist/modules/swag/swag.css"),
					);

					// Build choices module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/choices/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/choices"),
							lib: {
								entry: resolve(__dirname, "modules/choices/components/folk-choices-dashboard.ts"),
								formats: ["es"],
								fileName: () => "folk-choices-dashboard.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-choices-dashboard.js",
								},
							},
						},
					});

					// Copy choices CSS
					mkdirSync(resolve(__dirname, "dist/modules/choices"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/choices/components/choices.css"),
						resolve(__dirname, "dist/modules/choices/choices.css"),
					);

					// Build funds module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/funds/components"),
						resolve: {
							alias: {
								"../lib/types": resolve(__dirname, "modules/funds/lib/types.ts"),
								"../lib/simulation": resolve(__dirname, "modules/funds/lib/simulation.ts"),
								"../lib/presets": resolve(__dirname, "modules/funds/lib/presets.ts"),
							},
						},
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/funds"),
							lib: {
								entry: resolve(__dirname, "modules/funds/components/folk-budget-river.ts"),
								formats: ["es"],
								fileName: () => "folk-budget-river.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-budget-river.js",
								},
							},
						},
					});

					// Copy funds CSS
					mkdirSync(resolve(__dirname, "dist/modules/funds"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/funds/components/funds.css"),
						resolve(__dirname, "dist/modules/funds/funds.css"),
					);

					// Build files module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/files/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/files"),
							lib: {
								entry: resolve(__dirname, "modules/files/components/folk-file-browser.ts"),
								formats: ["es"],
								fileName: () => "folk-file-browser.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-file-browser.js",
								},
							},
						},
					});

					// Copy files CSS
					mkdirSync(resolve(__dirname, "dist/modules/files"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/files/components/files.css"),
						resolve(__dirname, "dist/modules/files/files.css"),
					);

					// Build forum module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/forum/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/forum"),
							lib: {
								entry: resolve(__dirname, "modules/forum/components/folk-forum-dashboard.ts"),
								formats: ["es"],
								fileName: () => "folk-forum-dashboard.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-forum-dashboard.js",
								},
							},
						},
					});

					// Copy forum CSS
					mkdirSync(resolve(__dirname, "dist/modules/forum"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/forum/components/forum.css"),
						resolve(__dirname, "dist/modules/forum/forum.css"),
					);

					// Build wallet module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/wallet/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/wallet"),
							lib: {
								entry: resolve(__dirname, "modules/wallet/components/folk-wallet-viewer.ts"),
								formats: ["es"],
								fileName: () => "folk-wallet-viewer.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-wallet-viewer.js",
								},
							},
						},
					});

					// Copy wallet CSS
					mkdirSync(resolve(__dirname, "dist/modules/wallet"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/wallet/components/wallet.css"),
						resolve(__dirname, "dist/modules/wallet/wallet.css"),
					);

					// Build vote module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/vote/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/vote"),
							lib: {
								entry: resolve(__dirname, "modules/vote/components/folk-vote-dashboard.ts"),
								formats: ["es"],
								fileName: () => "folk-vote-dashboard.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-vote-dashboard.js",
								},
							},
						},
					});

					// Copy vote CSS
					mkdirSync(resolve(__dirname, "dist/modules/vote"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/vote/components/vote.css"),
						resolve(__dirname, "dist/modules/vote/vote.css"),
					);

					// Build notes module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/notes/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/notes"),
							lib: {
								entry: resolve(__dirname, "modules/notes/components/folk-notes-app.ts"),
								formats: ["es"],
								fileName: () => "folk-notes-app.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-notes-app.js",
								},
							},
						},
					});

					// Copy notes CSS
					mkdirSync(resolve(__dirname, "dist/modules/notes"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/notes/components/notes.css"),
						resolve(__dirname, "dist/modules/notes/notes.css"),
					);

					// Build maps module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/maps/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/maps"),
							lib: {
								entry: resolve(__dirname, "modules/maps/components/folk-map-viewer.ts"),
								formats: ["es"],
								fileName: () => "folk-map-viewer.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-map-viewer.js",
								},
							},
						},
					});

					// Copy maps CSS
					mkdirSync(resolve(__dirname, "dist/modules/maps"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/maps/components/maps.css"),
						resolve(__dirname, "dist/modules/maps/maps.css"),
					);

					// Build work module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/work/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/work"),
							lib: {
								entry: resolve(__dirname, "modules/work/components/folk-work-board.ts"),
								formats: ["es"],
								fileName: () => "folk-work-board.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-work-board.js",
								},
							},
						},
					});

					// Copy work CSS
					mkdirSync(resolve(__dirname, "dist/modules/work"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/work/components/work.css"),
						resolve(__dirname, "dist/modules/work/work.css"),
					);

					// Build trips module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/trips/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/trips"),
							lib: {
								entry: resolve(__dirname, "modules/trips/components/folk-trips-planner.ts"),
								formats: ["es"],
								fileName: () => "folk-trips-planner.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-trips-planner.js",
								},
							},
						},
					});

					// Copy trips CSS
					mkdirSync(resolve(__dirname, "dist/modules/trips"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/trips/components/trips.css"),
						resolve(__dirname, "dist/modules/trips/trips.css"),
					);

					// Build cal module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/cal/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/cal"),
							lib: {
								entry: resolve(__dirname, "modules/cal/components/folk-calendar-view.ts"),
								formats: ["es"],
								fileName: () => "folk-calendar-view.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-calendar-view.js",
								},
							},
						},
					});

					// Copy cal CSS
					mkdirSync(resolve(__dirname, "dist/modules/cal"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/cal/components/cal.css"),
						resolve(__dirname, "dist/modules/cal/cal.css"),
					);

					// Build network module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/network/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/network"),
							lib: {
								entry: resolve(__dirname, "modules/network/components/folk-graph-viewer.ts"),
								formats: ["es"],
								fileName: () => "folk-graph-viewer.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-graph-viewer.js",
								},
							},
						},
					});

					// Copy network CSS
					mkdirSync(resolve(__dirname, "dist/modules/network"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/network/components/network.css"),
						resolve(__dirname, "dist/modules/network/network.css"),
					);

					// Build tube module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/tube/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/tube"),
							lib: {
								entry: resolve(__dirname, "modules/tube/components/folk-video-player.ts"),
								formats: ["es"],
								fileName: () => "folk-video-player.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-video-player.js",
								},
							},
						},
					});

					// Copy tube CSS
					mkdirSync(resolve(__dirname, "dist/modules/tube"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/tube/components/tube.css"),
						resolve(__dirname, "dist/modules/tube/tube.css"),
					);

					// Build inbox module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/inbox/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/inbox"),
							lib: {
								entry: resolve(__dirname, "modules/inbox/components/folk-inbox-client.ts"),
								formats: ["es"],
								fileName: () => "folk-inbox-client.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-inbox-client.js",
								},
							},
						},
					});

					// Copy inbox CSS
					mkdirSync(resolve(__dirname, "dist/modules/inbox"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/inbox/components/inbox.css"),
						resolve(__dirname, "dist/modules/inbox/inbox.css"),
					);

					// Build data module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/data/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/data"),
							lib: {
								entry: resolve(__dirname, "modules/data/components/folk-analytics-view.ts"),
								formats: ["es"],
								fileName: () => "folk-analytics-view.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-analytics-view.js",
								},
							},
						},
					});

					// Copy data CSS
					mkdirSync(resolve(__dirname, "dist/modules/data"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/data/components/data.css"),
						resolve(__dirname, "dist/modules/data/data.css"),
					);

					// Build route planner component (part of trips module)
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/trips/components"),
						resolve: {
							alias: {
								"../lib/types": resolve(__dirname, "modules/trips/lib/types.ts"),
								"../lib/conic-math": resolve(__dirname, "modules/trips/lib/conic-math.ts"),
								"../lib/projection": resolve(__dirname, "modules/trips/lib/projection.ts"),
							},
						},
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/trips"),
							lib: {
								entry: resolve(__dirname, "modules/trips/components/folk-route-planner.ts"),
								formats: ["es"],
								fileName: () => "folk-route-planner.js",
							},
							rollupOptions: {
								output: {
									entryFileNames: "folk-route-planner.js",
								},
							},
						},
					});

					// Copy route planner CSS
					copyFileSync(
						resolve(__dirname, "modules/trips/components/route-planner.css"),
						resolve(__dirname, "dist/modules/trips/route-planner.css"),
					);

					// Build splat module component
					await build({
						configFile: false,
						root: resolve(__dirname, "modules/splat/components"),
						build: {
							emptyOutDir: false,
							outDir: resolve(__dirname, "dist/modules/splat"),
							lib: {
								entry: resolve(__dirname, "modules/splat/components/folk-splat-viewer.ts"),
								formats: ["es"],
								fileName: () => "folk-splat-viewer.js",
							},
							rollupOptions: {
								external: ["three", "three/addons/", "@mkkellogg/gaussian-splats-3d"],
								output: {
									entryFileNames: "folk-splat-viewer.js",
								},
							},
						},
					});

					// Copy splat CSS
					mkdirSync(resolve(__dirname, "dist/modules/splat"), { recursive: true });
					copyFileSync(
						resolve(__dirname, "modules/splat/components/splat.css"),
						resolve(__dirname, "dist/modules/splat/splat.css"),
					);
				},
			},
		},
	],
	resolve: {
		alias: {
			"@lib": resolve(__dirname, "./lib"),
			"@encryptid": resolve(__dirname, "./src/encryptid"),
			"@shared": resolve(__dirname, "./shared"),
		},
	},
	build: {
		target: "esnext",
		rollupOptions: {
			input: {
				index: resolve(__dirname, "./website/index.html"),
				canvas: resolve(__dirname, "./website/canvas.html"),
				"create-space": resolve(__dirname, "./website/create-space.html"),
			},
		},
		modulePreload: {
			polyfill: false,
		},
		outDir: "../dist",
		emptyOutDir: true,
		// Copy shell.css to dist
		cssCodeSplit: false,
	},
	server: {
		port: 5173,
	},
	optimizeDeps: {
		exclude: ["@automerge/automerge"],
	},
});