/**
 * Creates a new stack.
 *
 * @param name Stack name.
 * @param parameters Input parameters.
 * @param templatePath Classpath to the JSON template of the stack.
 * @return Stack ID
 */
public String createStack(final String name,final Map<String,String> parameters,final String templatePath,final boolean iamCapabilities) {
    logger.info(String.format("Executing the Cloud Formation: %s,Stack Name: %s",templatePath,name));

    final CreateStackRequest request = new CreateStackRequest()
            .withStackName(name)
            .withParameters(convertParameters(parameters))
            .withTemplateBody(getTemplateText(templatePath));

    if (iamCapabilities) {
        request.getCapabilities().add("CAPABILITY_IAM");
    }

    final CreateStackResult result = cloudFormationClient.createStack(request);
    return result.getStackId();
}

public static StackNameAndId createTemporarySimpleStack(AmazonCloudFormation cfnClient,String vpcId,String arn) throws IOException {
    CreateStackRequest createStackRequest = new CreateStackRequest();
    createStackRequest.setStackName(TEMPORARY_STACK);
    File file = new File(FilesForTesting.SIMPLE_STACK);
    createStackRequest.setTemplateBody(FileUtils.readFiletoString(file,Charset.defaultCharset()));
    Collection<Parameter> parameters = new LinkedList<>();
    parameters.add(createParam("env",EnvironmentSetupForTests.ENV));
    parameters.add(createParam("vpc",vpcId));
    if (!arn.isEmpty()) {
        Collection<String> notificationARNs = new LinkedList<>();
        notificationARNs.add(arn);
        logger.debug("Adding arn subscription "+ arn);
        createStackRequest.setNotificationARNs(notificationARNs);
    }
    createStackRequest.setParameters(parameters);
    CreateStackResult result = cfnClient.createStack(createStackRequest);
    return new StackNameAndId(TEMPORARY_STACK,result.getStackId());
}

private DescribeStackResourcesResult getStackResources(String stackName) throws InterruptedException,IOException {
    try {
        DescribeStacksResult describeStacksResult = this.amazonCloudFormationClient.describeStacks(new DescribeStacksRequest().withStackName(stackName));
        for (Stack stack : describeStacksResult.getStacks()) {
            if (isAvailable(stack)) {
                return this.amazonCloudFormationClient.describeStackResources(new DescribeStackResourcesRequest().withStackName(stack.getStackName()));
            }
            if (isError(stack)) {
                if (this.stackCreatedByThisinstance) {
                    throw new IllegalArgumentException("Could not create stack");
                }
                this.amazonCloudFormationClient.deleteStack(new DeleteStackRequest().withStackName(stack.getStackName()));
                return getStackResources(stackName);
            }
            if (isInProgress(stack)) {
                //noinspection BusyWait
                Thread.sleep(5000L);
                return getStackResources(stackName);
            }
        }
    } catch (AmazonClientException e) {
        String templateBody = FilecopyUtils.copyToString(new InputStreamReader(new ClassPathResource(TEMPLATE_PATH).getInputStream()));
        this.amazonCloudFormationClient.createStack(new CreateStackRequest().withTemplateBody(templateBody).withOnFailure(OnFailure.DELETE).
                withStackName(stackName).withTags(new Tag().withKey("tag1").withValue("value1")).
                withParameters(new Parameter().withParameterKey("RdsPassword").withParameterValue(this.rdsPassword)));
        this.stackCreatedByThisinstance = true;
    }

    return getStackResources(stackName);
}

public void execute() {
    checkParams();
    AmazonCloudFormationClient client = getorCreateClient(AmazonCloudFormationClient.class);
    CreateStackRequest createStackRequest = new CreateStackRequest()
            .withdisableRollback(disableRollback).withOnFailure(onFailure)
            .withStackName(stackName).withStackPolicyBody(stackPolicyBody)
            .withStackPolicyURL(stackPolicyURL)
            .withTemplateBody(templateBody).withTemplateURL(templateURL)
            .withTimeoutInMinutes(timeoutInMinutes);

    if (capabilities.size() > 0) {
        createStackRequest.setCapabilities(capabilities);
    }
    if (parameters.size() > 0) {
        createStackRequest.setParameters(parameters);
    }
    if (tags.size() > 0) {
        createStackRequest.setTags(tags);
    }
    try {
        client.createStack(createStackRequest);
        System.out.println("Create stack " + stackName
                + " request submitted.");
        if(waitForCreation) {
            WaitForStackToReachStateTask.waitForCloudFormationStackToReachStatus(client,stackName,CREATE_COMPLETE);
        }
    } catch (Exception e) {
        throw new BuildException(
                "Could not create stack " + e.getMessage(),e);
    }
}

private CreateStackRequest createCreateStackRequest(AuthenticatedContext ac,CloudStack stack,String cFStackName,String subnet,String cfTemplate) {
    return new CreateStackRequest()
            .withStackName(cFStackName)
            .withOnFailure(OnFailure.DO_nothing)
            .withTemplateBody(cfTemplate)
            .withTags(awsTagPreparationService.prepareTags(ac,stack.getTags()))
            .withCapabilities(CAPABILITY_IAM)
            .withParameters(getStackParameters(ac,stack,cFStackName,subnet));
}

@Test
@Parameters({ "networkName","description","publicInAccount","regionName","vpcStackName","vpcName","existingsubnet" })
public void createNetwork(String networkName,@Optional("") String description,@Optional("false") boolean publicInAccount,String regionName,@Optional("it-vpc-stack") String vpcStackName,@Optional("it-vpc") String vpcName,boolean existingsubnet) {
    AmazonCloudFormationClient client = new AmazonCloudFormationClient();
    client.setRegion(RegionUtils.getRegion(regionName));

    Map<String,Object> networkMap = new HashMap<>();

    String vpcCreationjson = existingsubnet ?  "public_vpc_with_subnet.json" : "public_vpc_wihout_subnet.json";

    try (InputStream vpcJsonInputStream = getClass().getResourceAsstream("/cloudformation/" + vpcCreationjson)) {
        String vpcCFTemplateString = IoUtils.toString(vpcJsonInputStream);
        CreateStackRequest stackRequest = createStackRequest(vpcStackName,vpcName,vpcCFTemplateString);
        client.createStack(stackRequest);

        List<Output> outputForRequest = getoutputForRequest(vpcStackName,client);
        if (existingsubnet) {
            networkMap.put("vpcId",outputForRequest.get(0).getoutputValue());
            networkMap.put("subnetId",outputForRequest.get(1).getoutputValue());
        } else {
            networkMap.put("vpcId",outputForRequest.get(1).getoutputValue());
            networkMap.put("internetGatewayId",outputForRequest.get(0).getoutputValue());
        }
    } catch (IOException e) {
        LOGGER.error("can't read vpc cloudformation template file");
        throw new RuntimeException(e);
    }

    NetworkRequest networkRequest = new NetworkRequest();
    networkRequest.setName(networkName);
    networkRequest.setDescription(description);
    networkRequest.setParameters(networkMap);
    if (!existingsubnet) {
        networkRequest.setsubnetCIDR("10.0.0.0/24");
    }
    networkRequest.setCloudplatform("AWS");
    String id = getCloudbreakClient().networkEndpoint().postPrivate(networkRequest).getId().toString();
    getItContext().putContextParam(CloudbreakITContextConstants.NETWORK_ID,id,true);
}

@Override
protected void before() throws Throwable {
    try {
        String awsCredentialsDir = System.getProperty("aws.credentials.path");
        File awsCredentialsFile = new File(awsCredentialsDir,"aws.credentials.properties");
        Properties awsCredentials = new Properties();
        awsCredentials.load(new FileReader(awsCredentialsFile));
        String accessKey = awsCredentials.getProperty("cloud.aws.credentials.accessKey");
        String secretKey = awsCredentials.getProperty("cloud.aws.credentials.secretKey");
        this.cloudFormation = new AmazonCloudFormationClient(new BasicAWSCredentials(accessKey,secretKey));

        YamlPropertiesfactorybean yamlPropertiesfactorybean = new YamlPropertiesfactorybean();
        yamlPropertiesfactorybean.setResources(new ClassPathResource("application.yml"));
        Properties applicationProperties = yamlPropertiesfactorybean.getobject();

        this.stackName = applicationProperties.getProperty("cloud.aws.stack.name");

        after();

        ClassPathResource stackTemplate = new ClassPathResource("AwsIntegrationTestTemplate.json");
        String templateBody = FilecopyUtils.copyToString(new InputStreamReader(stackTemplate.getInputStream()));

        this.cloudFormation.createStack(
                new CreateStackRequest()
                        .withTemplateBody(templateBody)
                        .withOnFailure(OnFailure.DELETE)
                        .withStackName(this.stackName));

        waitForCompletion();

        System.setProperty("cloud.aws.credentials.accessKey",accessKey);
        System.setProperty("cloud.aws.credentials.secretKey",secretKey);
    }
    catch (Exception e) {
        if (!(e instanceof AssumptionViolatedException)) {
            Assume.assumeTrue("Can't perform AWS integration test because of: " + e.getMessage(),false);
        }
        else {
            throw e;
        }
    }
}

@Override
public void addMonitoringTo(CreateStackRequest createStackRequest) {
    // does nothing in this implementation
}

@Override
public void addMonitoringTo(CreateStackRequest createStackRequest) throws NotReadyException {
    Collection<String> arns = getArns();
    createStackRequest.setNotificationARNs(arns);
}

/**
 */
public Stack stackCreate() throws Exception {

    final CreateStackRequest request = new CreateStackRequest();

    request.withStackName(name);
    request.withParameters(paramList);
    request.withTemplateBody(template);

    amazonClient.createStack(request);

    final Stack stack = waitForStackCreate();

    return stack;

}

void addMonitoringTo(CreateStackRequest createStackRequest) throws NotReadyException;

/**
 * Creates a new stack.
 *
 * @param name Stack name.
 * @param parameters Input parameters.
 * @param templatePath Classpath to the JSON template of the stack.
 * @return Stack ID
 */
public String createStack(final String name,final Map<String,String> parameters,final String templatePath,final boolean iamCapabilities) {
    logger.info(String.format("Executing the Cloud Formation: %s,Stack Name: %s",templatePath,name));

    final CreateStackRequest request = new CreateStackRequest()
            .withStackName(name)
            .withParameters(convertParameters(parameters))
            .withTemplateBody(getTemplateText(templatePath));

    if (iamCapabilities) {
        request.getCapabilities().add("CAPABILITY_IAM");
    }

    final CreateStackResult result = cloudFormationClient.createStack(request);
    return result.getStackId();
}

public static StackNameAndId createTemporarySimpleStack(AmazonCloudFormation cfnClient,String vpcId,String arn) throws IOException {
    CreateStackRequest createStackRequest = new CreateStackRequest();
    createStackRequest.setStackName(TEMPORARY_STACK);
    File file = new File(FilesForTesting.SIMPLE_STACK);
    createStackRequest.setTemplateBody(FileUtils.readFiletoString(file,Charset.defaultCharset()));
    Collection<Parameter> parameters = new LinkedList<>();
    parameters.add(createParam("env",EnvironmentSetupForTests.ENV));
    parameters.add(createParam("vpc",vpcId));
    if (!arn.isEmpty()) {
        Collection<String> notificationARNs = new LinkedList<>();
        notificationARNs.add(arn);
        logger.debug("Adding arn subscription "+ arn);
        createStackRequest.setNotificationARNs(notificationARNs);
    }
    createStackRequest.setParameters(parameters);
    CreateStackResult result = cfnClient.createStack(createStackRequest);
    return new StackNameAndId(TEMPORARY_STACK,result.getStackId());
}