import * as cdk from 'aws-cdk-lib';
import * as autoscaling from 'aws-cdk-lib/aws-autoscaling';
import * as ec2 from 'aws-cdk-lib/aws-ec2';
import * as ecs from 'aws-cdk-lib/aws-ecs';
import * as iam from 'aws-cdk-lib/aws-iam';
import type { Construct } from 'constructs';

export class MinimalWindowsClusterStack extends cdk.Stack {
    constructor(scope: Construct) {
        super(scope, 'WindowsClusterMinimal');

        const vpc = new ec2.Vpc(this, 'Vpc', { maxAzs: 2 });

        const clusterName = 'windows';

        const cluster = new ecs.Cluster(this, 'Cluster', {
            clusterName,
            vpc,
        });

        const taskDefinition = new ecs.TaskDefinition(
            this,
            'TaskDefinition',
            {
                compatibility: ecs.Compatibility.EC2,
                cpu: '512',
                memoryMiB: '1024',
                runtimePlatform: {
                    operatingSystemFamily:
                        ecs.OperatingSystemFamily.WINDOWS_SERVER_2022_CORE,
                },
            },
        );

        taskDefinition.addContainer('App', {
            image: ecs.ContainerImage.fromRegistry(
                'mcr.microsoft.com/windows/servercore:ltsc2022',
            ),
            memoryReservationMiB: 512,
            portMappings: [
                {
                    containerPort: 80,
                    protocol: ecs.Protocol.TCP,
                },
            ],
        });

        const instanceRole = new iam.Role(this, 'InstanceRole', {
            assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
        });
        instanceRole.addManagedPolicy(
            iam.ManagedPolicy.fromAwsManagedPolicyName(
                'service-role/AmazonEC2ContainerServiceforEC2Role',
            ),
        );

        const launchTemplate = new ec2.LaunchTemplate(this, 'LaunchTemplate', {
            instanceType: ec2.InstanceType.of(
                ec2.InstanceClass.T3A,
                ec2.InstanceSize.XLARGE2,
            ),
            machineImage: ecs.EcsOptimizedImage.windows(
                ecs.WindowsOptimizedVersion.SERVER_2022,
            ),
            role: instanceRole,
            userData: ec2.UserData.forWindows(),
        });

        const autoScalingGroup = new autoscaling.AutoScalingGroup(
            this,
            'AutoScalingGroup',
            {
                vpc,
                minCapacity: 1,
                maxCapacity: 2,
                launchTemplate,
            },
        );

        const capacityProvider = new ecs.AsgCapacityProvider(
            this,
            'AsgCapacityProvider',
            {
                autoScalingGroup,
                capacityProviderName: 'EC2_WINDOWS_2022',
            },
        );

        cluster.addAsgCapacityProvider(capacityProvider);

        new ecs.Ec2Service(this, 'Service', {
            cluster,
            taskDefinition,
            desiredCount: 1,
            capacityProviderStrategies: [
                {
                    capacityProvider: capacityProvider.capacityProviderName,
                    weight: 1,
                },
            ],
        });
    }
}