import {
	base64Encode,
	decrypt,
	encrypt,
	executeCommand,
	generateSecrets,
	generateTimestamp,
	getDomain,
	isARM,
	isDev,
	prisma,
	version
} from '../common';
import { promises as fs } from 'fs';
import { day } from '../dayjs';

const staticApps = ['static', 'react', 'vuejs', 'svelte', 'gatsby', 'astro', 'eleventy'];
const nodeBased = [
	'react',
	'preact',
	'vuejs',
	'svelte',
	'gatsby',
	'astro',
	'eleventy',
	'node',
	'nestjs',
	'nuxtjs',
	'nextjs'
];

export function setDefaultBaseImage(
	buildPack: string | null,
	deploymentType: string | null = null
) {
	const nodeVersions = [
		{
			value: 'node:lts',
			label: 'node:lts'
		},
		{
			value: 'node:18',
			label: 'node:18'
		},
		{
			value: 'node:17',
			label: 'node:17'
		},
		{
			value: 'node:16',
			label: 'node:16'
		},
		{
			value: 'node:14',
			label: 'node:14'
		},
		{
			value: 'node:12',
			label: 'node:12'
		}
	];
	const staticVersions = [
		{
			value: 'webdevops/nginx:alpine',
			label: 'webdevops/nginx:alpine'
		},
		{
			value: 'webdevops/apache:alpine',
			label: 'webdevops/apache:alpine'
		},
		{
			value: 'nginx:alpine',
			label: 'nginx:alpine'
		},
		{
			value: 'httpd:alpine',
			label: 'httpd:alpine (Apache)'
		}
	];
	const rustVersions = [
		{
			value: 'rust:latest',
			label: 'rust:latest'
		},
		{
			value: 'rust:1.60',
			label: 'rust:1.60'
		},
		{
			value: 'rust:1.60-buster',
			label: 'rust:1.60-buster'
		},
		{
			value: 'rust:1.60-bullseye',
			label: 'rust:1.60-bullseye'
		},
		{
			value: 'rust:1.60-slim-buster',
			label: 'rust:1.60-slim-buster'
		},
		{
			value: 'rust:1.60-slim-bullseye',
			label: 'rust:1.60-slim-bullseye'
		},
		{
			value: 'rust:1.60-alpine3.14',
			label: 'rust:1.60-alpine3.14'
		},
		{
			value: 'rust:1.60-alpine3.15',
			label: 'rust:1.60-alpine3.15'
		}
	];
	const phpVersions = [
		{
			value: 'webdevops/php-apache:8.2',
			label: 'webdevops/php-apache:8.2'
		},
		{
			value: 'webdevops/php-nginx:8.2',
			label: 'webdevops/php-nginx:8.2'
		},
		{
			value: 'webdevops/php-apache:8.1',
			label: 'webdevops/php-apache:8.1'
		},
		{
			value: 'webdevops/php-nginx:8.1',
			label: 'webdevops/php-nginx:8.1'
		},
		{
			value: 'webdevops/php-apache:8.0',
			label: 'webdevops/php-apache:8.0'
		},
		{
			value: 'webdevops/php-nginx:8.0',
			label: 'webdevops/php-nginx:8.0'
		},
		{
			value: 'webdevops/php-apache:7.4',
			label: 'webdevops/php-apache:7.4'
		},
		{
			value: 'webdevops/php-nginx:7.4',
			label: 'webdevops/php-nginx:7.4'
		},
		{
			value: 'webdevops/php-apache:7.3',
			label: 'webdevops/php-apache:7.3'
		},
		{
			value: 'webdevops/php-nginx:7.3',
			label: 'webdevops/php-nginx:7.3'
		},
		{
			value: 'webdevops/php-apache:7.2',
			label: 'webdevops/php-apache:7.2'
		},
		{
			value: 'webdevops/php-nginx:7.2',
			label: 'webdevops/php-nginx:7.2'
		},
		{
			value: 'webdevops/php-apache:7.1',
			label: 'webdevops/php-apache:7.1'
		},
		{
			value: 'webdevops/php-nginx:7.1',
			label: 'webdevops/php-nginx:7.1'
		},
		{
			value: 'webdevops/php-apache:7.0',
			label: 'webdevops/php-apache:7.0'
		},
		{
			value: 'webdevops/php-nginx:7.0',
			label: 'webdevops/php-nginx:7.0'
		},
		{
			value: 'webdevops/php-apache:5.6',
			label: 'webdevops/php-apache:5.6'
		},
		{
			value: 'webdevops/php-nginx:5.6',
			label: 'webdevops/php-nginx:5.6'
		},
		{
			value: 'webdevops/php-apache:8.2-alpine',
			label: 'webdevops/php-apache:8.2-alpine'
		},
		{
			value: 'webdevops/php-nginx:8.2-alpine',
			label: 'webdevops/php-nginx:8.2-alpine'
		},
		{
			value: 'webdevops/php-apache:8.1-alpine',
			label: 'webdevops/php-apache:8.1-alpine'
		},
		{
			value: 'webdevops/php-nginx:8.1-alpine',
			label: 'webdevops/php-nginx:8.1-alpine'
		},
		{
			value: 'webdevops/php-apache:8.0-alpine',
			label: 'webdevops/php-apache:8.0-alpine'
		},
		{
			value: 'webdevops/php-nginx:8.0-alpine',
			label: 'webdevops/php-nginx:8.0-alpine'
		},
		{
			value: 'webdevops/php-apache:7.4-alpine',
			label: 'webdevops/php-apache:7.4-alpine'
		},
		{
			value: 'webdevops/php-nginx:7.4-alpine',
			label: 'webdevops/php-nginx:7.4-alpine'
		},
		{
			value: 'webdevops/php-apache:7.3-alpine',
			label: 'webdevops/php-apache:7.3-alpine'
		},
		{
			value: 'webdevops/php-nginx:7.3-alpine',
			label: 'webdevops/php-nginx:7.3-alpine'
		},
		{
			value: 'webdevops/php-apache:7.2-alpine',
			label: 'webdevops/php-apache:7.2-alpine'
		},
		{
			value: 'webdevops/php-nginx:7.2-alpine',
			label: 'webdevops/php-nginx:7.2-alpine'
		},
		{
			value: 'webdevops/php-apache:7.1-alpine',
			label: 'webdevops/php-apache:7.1-alpine'
		},
		{
			value: 'php:8.1-fpm',
			label: 'php:8.1-fpm'
		},
		{
			value: 'php:8.0-fpm',
			label: 'php:8.0-fpm'
		},
		{
			value: 'php:8.1-fpm-alpine',
			label: 'php:8.1-fpm-alpine'
		},
		{
			value: 'php:8.0-fpm-alpine',
			label: 'php:8.0-fpm-alpine'
		}
	];
	const pythonVersions = [
		{
			value: 'python:3.10-alpine',
			label: 'python:3.10-alpine'
		},
		{
			value: 'python:3.10-buster',
			label: 'python:3.10-buster'
		},
		{
			value: 'python:3.10-bullseye',
			label: 'python:3.10-bullseye'
		},
		{
			value: 'python:3.10-slim-bullseye',
			label: 'python:3.10-slim-bullseye'
		},
		{
			value: 'python:3.9-alpine',
			label: 'python:3.9-alpine'
		},
		{
			value: 'python:3.9-buster',
			label: 'python:3.9-buster'
		},
		{
			value: 'python:3.9-bullseye',
			label: 'python:3.9-bullseye'
		},
		{
			value: 'python:3.9-slim-bullseye',
			label: 'python:3.9-slim-bullseye'
		},
		{
			value: 'python:3.8-alpine',
			label: 'python:3.8-alpine'
		},
		{
			value: 'python:3.8-buster',
			label: 'python:3.8-buster'
		},
		{
			value: 'python:3.8-bullseye',
			label: 'python:3.8-bullseye'
		},
		{
			value: 'python:3.8-slim-bullseye',
			label: 'python:3.8-slim-bullseye'
		},
		{
			value: 'python:3.7-alpine',
			label: 'python:3.7-alpine'
		},
		{
			value: 'python:3.7-buster',
			label: 'python:3.7-buster'
		},
		{
			value: 'python:3.7-bullseye',
			label: 'python:3.7-bullseye'
		},
		{
			value: 'python:3.7-slim-bullseye',
			label: 'python:3.7-slim-bullseye'
		}
	];
	const herokuVersions = [
		{
			value: 'heroku/builder:22',
			label: 'heroku/builder:22'
		},
		{
			value: 'heroku/buildpacks:20',
			label: 'heroku/buildpacks:20'
		},
		{
			value: 'heroku/builder-classic:22',
			label: 'heroku/builder-classic:22'
		}
	];
	let payload: any = {
		baseImage: null,
		baseBuildImage: null,
		baseImages: [],
		baseBuildImages: []
	};
	if (nodeBased.includes(buildPack)) {
		if (deploymentType === 'static') {
			payload.baseImage = isARM(process.arch) ? 'nginx:alpine' : 'webdevops/nginx:alpine';
			payload.baseImages = isARM(process.arch)
				? staticVersions.filter((version) => !version.value.includes('webdevops'))
				: staticVersions;
			payload.baseBuildImage = 'node:lts';
			payload.baseBuildImages = nodeVersions;
		} else {
			payload.baseImage = 'node:lts';
			payload.baseImages = nodeVersions;
			payload.baseBuildImage = 'node:lts';
			payload.baseBuildImages = nodeVersions;
		}
	}
	if (staticApps.includes(buildPack)) {
		payload.baseImage = isARM(process.arch) ? 'nginx:alpine' : 'webdevops/nginx:alpine';
		payload.baseImages = isARM(process.arch)
			? staticVersions.filter((version) => !version.value.includes('webdevops'))
			: staticVersions;
		payload.baseBuildImage = 'node:lts';
		payload.baseBuildImages = nodeVersions;
	}
	if (buildPack === 'python') {
		payload.baseImage = 'python:3.10-alpine';
		payload.baseImages = pythonVersions;
	}
	if (buildPack === 'rust') {
		payload.baseImage = 'rust:latest';
		payload.baseBuildImage = 'rust:latest';
		payload.baseImages = rustVersions;
		payload.baseBuildImages = rustVersions;
	}
	if (buildPack === 'deno') {
		payload.baseImage = 'denoland/deno:latest';
	}
	if (buildPack === 'php') {
		payload.baseImage = isARM(process.arch)
			? 'php:8.1-fpm-alpine'
			: 'webdevops/php-apache:8.2-alpine';
		payload.baseImages = isARM(process.arch)
			? phpVersions.filter((version) => !version.value.includes('webdevops'))
			: phpVersions;
	}
	if (buildPack === 'laravel') {
		payload.baseImage = isARM(process.arch)
			? 'php:8.1-fpm-alpine'
			: 'webdevops/php-apache:8.2-alpine';
		payload.baseImages = isARM(process.arch)
			? phpVersions.filter((version) => !version.value.includes('webdevops'))
			: phpVersions;
		payload.baseBuildImage = 'node:18';
		payload.baseBuildImages = nodeVersions;
	}
	if (buildPack === 'heroku') {
		payload.baseImage = 'heroku/buildpacks:20';
		payload.baseImages = herokuVersions;
	}
	return payload;
}

export const setDefaultConfiguration = async (data: any) => {
	let {
		buildPack,
		port,
		installCommand,
		startCommand,
		buildCommand,
		publishDirectory,
		baseDirectory,
		dockerFileLocation,
		dockerComposeFileLocation,
		denoMainFile
	} = data;
	//@ts-ignore
	const template = scanningTemplates[buildPack];
	if (!port) {
		port = template?.port || 3000;

		if (buildPack === 'static') port = 80;
		else if (buildPack === 'node') port = 3000;
		else if (buildPack === 'php') port = 80;
		else if (buildPack === 'python') port = 8000;
	}
	if (!installCommand && buildPack !== 'static' && buildPack !== 'laravel')
		installCommand = template?.installCommand || 'yarn install';
	if (!startCommand && buildPack !== 'static' && buildPack !== 'laravel')
		startCommand = template?.startCommand || 'yarn start';
	if (!buildCommand && buildPack !== 'static' && buildPack !== 'laravel')
		buildCommand = template?.buildCommand || null;
	if (!publishDirectory) publishDirectory = template?.publishDirectory || null;
	if (baseDirectory) {
		if (!baseDirectory.startsWith('/')) baseDirectory = `/${baseDirectory}`;
		if (baseDirectory.endsWith('/') && baseDirectory !== '/')
			baseDirectory = baseDirectory.slice(0, -1);
	}
	if (dockerFileLocation) {
		if (!dockerFileLocation.startsWith('/')) dockerFileLocation = `/${dockerFileLocation}`;
		if (dockerFileLocation.endsWith('/')) dockerFileLocation = dockerFileLocation.slice(0, -1);
	} else {
		dockerFileLocation = '/Dockerfile';
	}
	if (dockerComposeFileLocation) {
		if (!dockerComposeFileLocation.startsWith('/'))
			dockerComposeFileLocation = `/${dockerComposeFileLocation}`;
		if (dockerComposeFileLocation.endsWith('/'))
			dockerComposeFileLocation = dockerComposeFileLocation.slice(0, -1);
	} else {
		dockerComposeFileLocation = '/Dockerfile';
	}
	if (!denoMainFile) {
		denoMainFile = 'main.ts';
	}

	return {
		buildPack,
		port,
		installCommand,
		startCommand,
		buildCommand,
		publishDirectory,
		baseDirectory,
		dockerFileLocation,
		dockerComposeFileLocation,
		denoMainFile
	};
};

export const scanningTemplates = {
	'@sveltejs/kit': {
		buildPack: 'nodejs'
	},
	astro: {
		buildPack: 'astro'
	},
	'@11ty/eleventy': {
		buildPack: 'eleventy'
	},
	svelte: {
		buildPack: 'svelte'
	},
	'@nestjs/core': {
		buildPack: 'nestjs'
	},
	next: {
		buildPack: 'nextjs'
	},
	nuxt: {
		buildPack: 'nuxtjs'
	},
	'react-scripts': {
		buildPack: 'react'
	},
	'parcel-bundler': {
		buildPack: 'static'
	},
	'@vue/cli-service': {
		buildPack: 'vuejs'
	},
	vuejs: {
		buildPack: 'vuejs'
	},
	gatsby: {
		buildPack: 'gatsby'
	},
	'preact-cli': {
		buildPack: 'react'
	}
};

export const saveBuildLog = async ({
	line,
	buildId,
	applicationId
}: {
	line: string;
	buildId: string;
	applicationId: string;
}): Promise<any> => {
	if (buildId === 'undefined' || buildId === 'null' || !buildId) return;
	if (applicationId === 'undefined' || applicationId === 'null' || !applicationId) return;
	const { default: got } = await import('got');
	if (typeof line === 'object' && line) {
		if (line.shortMessage) {
			line = line.shortMessage + '\n' + line.stderr;
		} else {
			line = JSON.stringify(line);
		}
	}
	if (line && typeof line === 'string' && line.includes('ghs_')) {
		const regex = /ghs_.*@/g;
		line = line.replace(regex, '<SENSITIVE_DATA_DELETED>@');
	}
	const addTimestamp = `[${generateTimestamp()}] ${line}`;
	const fluentBitUrl = isDev
		? process.env.COOLIFY_CONTAINER_DEV === 'true'
			? 'http://coolify-fluentbit:24224'
			: 'http://localhost:24224'
		: 'http://coolify-fluentbit:24224';

	if (isDev && !process.env.COOLIFY_CONTAINER_DEV) {
		console.debug(`[${applicationId}] ${addTimestamp}`);
	}
	try {
		return await got.post(`${fluentBitUrl}/${applicationId}_buildlog_${buildId}.csv`, {
			json: {
				line: encrypt(line)
			}
		});
	} catch (error) {
		return await prisma.buildLog.create({
			data: {
				line: addTimestamp,
				buildId,
				time: Number(day().valueOf()),
				applicationId
			}
		});
	}
};

export async function copyBaseConfigurationFiles(
	buildPack,
	workdir,
	buildId,
	applicationId,
	baseImage
) {
	try {
		if (buildPack === 'php') {
			await fs.writeFile(`${workdir}/entrypoint.sh`, `chown -R 1000 /app`);
			await saveBuildLog({
				line: 'Copied default configuration file for PHP.',
				buildId,
				applicationId
			});
		} else if (baseImage?.includes('nginx')) {
			await fs.writeFile(
				`${workdir}/nginx.conf`,
				`user  nginx;
            worker_processes  auto;
            
            error_log  /docker.stdout;
            pid        /run/nginx.pid;
            
            events {
                worker_connections  1024;
            }
            
            http {
				log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
				'$status $body_bytes_sent "$http_referer" '
				'"$http_user_agent" "$http_x_forwarded_for"';

                access_log  /docker.stdout main;

				sendfile            on;
				tcp_nopush          on;
				tcp_nodelay         on;
				keepalive_timeout   65;
				types_hash_max_size 2048;

			    include             /etc/nginx/mime.types;
    			default_type        application/octet-stream;
				
                server {
                    listen       80;
                    server_name  localhost;
                    
                    location / {
                        root   /app;
                        index  index.html;
                        try_files $uri $uri/index.html $uri/ /index.html =404;
                    }
            
                    error_page  404              /50x.html;
            
                    # redirect server error pages to the static page /50x.html
                    #
                    error_page   500 502 503 504  /50x.html;
                    location = /50x.html {
                        root   /app;
                    }  
            
                }
            
            }
            `
			);
		}
		// TODO: Add more configuration files for other buildpacks, like apache2, etc.
	} catch (error) {
		throw new Error(error);
	}
}

export function checkPnpm(installCommand = null, buildCommand = null, startCommand = null) {
	return (
		installCommand?.includes('pnpm') ||
		buildCommand?.includes('pnpm') ||
		startCommand?.includes('pnpm')
	);
}

export async function saveDockerRegistryCredentials({ url, username, password, workdir }) {
	if (!username || !password) {
		return null;
	}

	let decryptedPassword = decrypt(password);
	const location = `${workdir}/.docker`;

	try {
		await fs.mkdir(`${workdir}/.docker`);
	} catch (error) {
		// console.log(error);
	}
	const payload = JSON.stringify({
		auths: {
			[url]: {
				auth: Buffer.from(`${username}:${decryptedPassword}`).toString('base64')
			}
		}
	});
	await fs.writeFile(`${location}/config.json`, payload);
	return location;
}
export async function buildImage({
	applicationId,
	tag,
	workdir,
	buildId,
	dockerId,
	isCache = false,
	debug = false,
	dockerFileLocation = '/Dockerfile',
	commit,
	forceRebuild = false
}) {
	if (isCache) {
		await saveBuildLog({ line: `Building cache image...`, buildId, applicationId });
	} else {
		await saveBuildLog({ line: `Building production image...`, buildId, applicationId });
	}
	const dockerFile = isCache ? `${dockerFileLocation}-cache` : `${dockerFileLocation}`;
	const cache = `${applicationId}:${tag}${isCache ? '-cache' : ''}`;
	let location = null;

	const { dockerRegistry } = await prisma.application.findUnique({
		where: { id: applicationId },
		select: { dockerRegistry: true }
	});
	if (dockerRegistry) {
		const { url, username, password } = dockerRegistry;
		location = await saveDockerRegistryCredentials({ url, username, password, workdir });
	}

	await executeCommand({
		stream: true,
		debug,
		buildId,
		applicationId,
		dockerId,
		command: `docker ${location ? `--config ${location}` : ''} build ${
			forceRebuild ? '--no-cache' : ''
		} --progress plain -f ${workdir}/${dockerFile} -t ${cache} --build-arg SOURCE_COMMIT=${commit} ${workdir}`
	});

	const { status } = await prisma.build.findUnique({ where: { id: buildId } });
	if (status === 'canceled') {
		throw new Error('Canceled.');
	}
}
export function makeLabelForSimpleDockerfile({ applicationId, port, type }) {
	return [
		'coolify.managed=true',
		`coolify.version=${version}`,
		`coolify.applicationId=${applicationId}`,
		`coolify.type=standalone-application`
	];
}
export function makeLabelForStandaloneApplication({
	applicationId,
	fqdn,
	name,
	type,
	pullmergeRequestId = null,
	buildPack,
	repository,
	branch,
	projectId,
	port,
	commit,
	installCommand,
	buildCommand,
	startCommand,
	baseDirectory,
	publishDirectory
}) {
	if (pullmergeRequestId) {
		const protocol = fqdn.startsWith('https://') ? 'https' : 'http';
		const domain = getDomain(fqdn);
		fqdn = `${protocol}://${pullmergeRequestId}.${domain}`;
	}
	return [
		'coolify.managed=true',
		`coolify.version=${version}`,
		`coolify.applicationId=${applicationId}`,
		`coolify.type=standalone-application`,
		`coolify.name=${name}`,
		`coolify.configuration=${base64Encode(
			JSON.stringify({
				applicationId,
				fqdn,
				name,
				type,
				pullmergeRequestId,
				buildPack,
				repository,
				branch,
				projectId,
				port,
				commit,
				installCommand,
				buildCommand,
				startCommand,
				baseDirectory,
				publishDirectory
			})
		)}`
	];
}

export async function buildCacheImageWithNode(data, imageForBuild) {
	const {
		workdir,
		buildId,
		baseDirectory,
		installCommand,
		buildCommand,
		secrets,
		pullmergeRequestId
	} = data;
	const isPnpm = checkPnpm(installCommand, buildCommand);
	const Dockerfile: Array<string> = [];
	Dockerfile.push(`FROM ${imageForBuild}`);
	Dockerfile.push('WORKDIR /app');
	Dockerfile.push(`LABEL coolify.buildId=${buildId}`);
	if (secrets.length > 0) {
		generateSecrets(secrets, pullmergeRequestId, true).forEach((env) => {
			Dockerfile.push(env);
		});
	}
	if (isPnpm) {
		Dockerfile.push('RUN curl -f https://get.pnpm.io/v6.16.js | node - add --global pnpm@7');
	}
	Dockerfile.push(`COPY .${baseDirectory || ''} ./`);
	if (installCommand) {
		Dockerfile.push(`RUN ${installCommand}`);
	}
	Dockerfile.push(`RUN ${buildCommand}`);
	await fs.writeFile(`${workdir}/Dockerfile-cache`, Dockerfile.join('\n'));
	await buildImage({ ...data, isCache: true });
}

export async function buildCacheImageForLaravel(data, imageForBuild) {
	const { workdir, buildId, secrets, pullmergeRequestId } = data;
	const Dockerfile: Array<string> = [];
	Dockerfile.push(`FROM ${imageForBuild}`);
	Dockerfile.push('WORKDIR /app');
	Dockerfile.push(`LABEL coolify.buildId=${buildId}`);
	if (secrets.length > 0) {
		generateSecrets(secrets, pullmergeRequestId, true).forEach((env) => {
			Dockerfile.push(env);
		});
	}
	Dockerfile.push(`COPY *.json *.mix.js /app/`);
	Dockerfile.push(`COPY resources /app/resources`);
	Dockerfile.push(`RUN yarn install && yarn production`);
	await fs.writeFile(`${workdir}/Dockerfile-cache`, Dockerfile.join('\n'));
	await buildImage({ ...data, isCache: true });
}

export async function buildCacheImageWithCargo(data, imageForBuild) {
	const { applicationId, workdir, buildId } = data;

	const Dockerfile: Array<string> = [];
	Dockerfile.push(`FROM ${imageForBuild} as planner-${applicationId}`);
	Dockerfile.push(`LABEL coolify.buildId=${buildId}`);
	Dockerfile.push('WORKDIR /app');
	Dockerfile.push('RUN cargo install cargo-chef');
	Dockerfile.push('COPY . .');
	Dockerfile.push('RUN cargo chef prepare --recipe-path recipe.json');
	Dockerfile.push(`FROM ${imageForBuild}`);
	Dockerfile.push(`LABEL coolify.buildId=${buildId}`);
	Dockerfile.push('WORKDIR /app');
	Dockerfile.push('RUN cargo install cargo-chef');
	Dockerfile.push(`COPY --from=planner-${applicationId} /app/recipe.json recipe.json`);
	Dockerfile.push('RUN cargo chef cook --release --recipe-path recipe.json');
	await fs.writeFile(`${workdir}/Dockerfile-cache`, Dockerfile.join('\n'));
	await buildImage({ ...data, isCache: true });
}