import {
	ConnectionDefinitions,
	CreateEventLinkPayload,
	CreateLinkPayload,
	EventLink,
	Link,
	LinkSettings,
} from '@event-inc/types';
import {
	makeHttpNetworkCall,
	matchResultAndHandleHttpError,
} from '@event-inc/utils';
import { identity } from 'ramda';
import jwt from 'jsonwebtoken';

export const createLinkTokenApi = <T extends 'source' | 'destination'>(
	headers: Record<string, string>,
	url: string,
	payload: CreateLinkPayload<T>
) => {
	return makeHttpNetworkCall<Link>({
		method: 'POST',
		url: `${url}/v1/links/create`,
		headers,
		data: payload,
	});
};

export const createEventLinkTokenApi = async (
	headers: Record<string, string>,
	url: string,
	payload: CreateEventLinkPayload,
	secret: string
) => {
	const settings = await makeHttpNetworkCall<LinkSettings>({
		method: 'POST',
		url: `${url}/v1/settings/get`,
		headers,
	});

	const { data } = matchResultAndHandleHttpError(settings, identity);

	const link = await makeHttpNetworkCall<EventLink>({
		method: 'POST',
		url: `${url}/v1/event-links/create`,
		headers,
		data: payload,
	});

	const { data: linkData } = matchResultAndHandleHttpError(link, identity);

	const connectionDefinitionUrl = url.includes('localhost')
		? 'http://localhost:3005/v1/connection-definitions'
		: url.includes('development')
		? 'https://development-api.event.dev/v1/connection-definitions'
		: 'https://api.event.dev/v1/connection-definitions';

	const connectionDefinitionHeaders = {
		'x-event-inc-secret': secret,
	};

	const connectionDefinitions =
		await makeHttpNetworkCall<ConnectionDefinitions>({
			method: 'GET',
			url: `${connectionDefinitionUrl}?limit=100&skip=0&active=false`,
			headers: connectionDefinitionHeaders,
		});

	const { data: inActiveConnectionDefinitionsData } =
		matchResultAndHandleHttpError(connectionDefinitions, identity);

	// Remove the platforms from the settings.connectedPlatforms that are not active
	const connectedPlatforms = data?.connectedPlatforms?.filter((platform) => {
		return !inActiveConnectionDefinitionsData?.rows?.find(
			(definition) => definition?._id === platform?.connectionDefinitionId
		);
	});

	// Remove the platforms whose platform.active is false
	const activeConnectedPlatforms = connectedPlatforms?.filter((platform) => {
		return platform?.active;
	});

	const tokenPayload = {
		linkSettings: {
			connectedPlatforms: activeConnectedPlatforms ?? [],
			eventIncToken: linkData?.token,
		},
		group: linkData?.group,
		label: linkData?.label,
	};
	const token = jwt.sign(tokenPayload, secret);

	return token;
};