import * as fs from 'fs';
import * as awsx from "@pulumi/awsx";
import * as aws from "@pulumi/aws";


const services = fs.readdirSync('./app').filter(path => /-service$/.test(path));

// Step 1: Create an ECS Fargate cluster.
const cluster = new awsx.ecs.Cluster("cluster");

// Step 2: Define the Networking for our service.
const alb = new awsx.lb.ApplicationLoadBalancer(
    "net-lb", { external: true, securityGroups: cluster.securityGroups });

const web = alb.createListener("web", { port: 80, external: true });

const getServiceSegment = (service) => service.replace(/-service$/, '');

services.forEach((service) => {

	const segment = getServiceSegment(service);

	// Build and publish a Docker image to a private ECR registry.
	const serviceImg = awsx.ecs.Image.fromPath(`${service}-img`, `./app/${service}`);

	// Create a Fargate service task that can scale out.
	const serviceTargetGroup = new aws.lb.TargetGroup(`${service}-target-group`, {
	    port: 80,
	    protocol: "HTTP",
	    vpcId: alb.vpc.id,
	    targetType: 'ip'
	});

	const service = new awsx.ecs.FargateService(service, {
	    cluster,
	    loadBalancers: [{
		containerName: `${service}-container`,
		containerPort: 80,
		targetGroupArn: serviceTargetGroup.arn

	    }],
	    taskDefinitionArgs: {
		containers: {
		    [`${service}-container`]: {
			portMappings: [{
			    containerPort: 80,

			}],
			image: serviceImg,
			cpu: 102 /*10% of 1024*/,
			memory: 50 /*MB*/,
		    }
		},
	    },
	    desiredCount: 3,
	});


	const listenerRule = new aws.lb.ListenerRule(`${service}-listener-rule`, {
	    listenerArn: web.listener.arn,
	    priority: 100,
	    actions: [{
		type: "forward",
		targetGroupArn: serviceTargetGroup.arn
	    }],
	    conditions: [
		{
		    pathPattern: {
			values: [`/${segment}`, `/${segment}/*`],
		    },
		}
	    ],
	});

})


// Step 5: Export the Internet address for the service.
export const url = web.endpoint.hostname;

.fromDockerBuild

DOCKER_BUILDKIT=1

const applicationImage = containerRepository.buildAndPushImage({
  env: {
    DOCKER_BUILDKIT: "1",
  },
});

ignoreChanges

pulumi stack init <stackname>

const gameserverShared = new pulumi.StackReference(gameserverSharedName);

const gameserverSharedAlbId = gameserverShared.getOutput("albId");
const gameserverSharedAlbSecurityGroupId = gameserverShared.getOutput("albSecurityGroupId");

const alb = new awsx.lb.ApplicationLoadBalancer(`${resourcePrefix}-lb`, {
  loadBalancer: aws.lb.LoadBalancer.get(`${resourcePrefix}-lb`, gameserverSharedAlbId, { vpcId: vpc.vpc.id }),
  external: true,
  securityGroups: [gameserverSharedAlbSecurityGroupId],
  vpc: vpc.vpc,
});

const appTargetGroup = new awsx.lb.ApplicationTargetGroup(`${resourcePrefix}-tg`, {
  deregistrationDelay: 0,
  healthCheck: { path: "/health", port: "443", protocol: "HTTPS", matcher: "200" },
  loadBalancer: alb,
  port: 443,
  protocol: "HTTPS",
  vpc: vpc.vpc,
  tags: autotag,
});

const https = new awsx.lb.ApplicationListener(`${resourcePrefix}-https`, {
  listener: aws.lb.Listener.get(`${resourcePrefix}-https`, gameserverSharedListenerHttpsId),
  loadBalancer: alb,
  targetGroup: appTargetGroup,
  vpc: vpc.vpc,
});

new awsx.lb.ListenerRule(`${resourcePrefix}-lr`, https, {
  actions: [{ targetGroupArn: appTargetGroup.targetGroup.arn.apply(v => v), type: "forward" }],
  conditions: [{ hostHeader: { values: [fqdn] } }],
});

new aws.route53.Record(appName, {
  aliases: [{ evaluateTargetHealth: true, name: alb.loadBalancer.dnsName, zoneId: elbServiceHostedZoneId }],
  name: fqdn.apply(v => v),
  type: "A",
  zoneId: hostedZoneId,
});

vpc.vpc

vpc