/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

#include <unistd.h>
#include <stdio.h>
#include <sys/time.h>
#include "libyarn/LibYarnClientC.h"
#include "libyarn/LibYarnConstants.h"

int main() {
		char *rmHost = "master";
		char *rmPort = "8032";
		char *schedHost = "master";
		char *schedPort = "8030";
		char *amHost = "master";
		int32_t amPort = 8090;
		char *am_tracking_url = "url";
		int heartbeatInterval = 1000000;
		int i=0;

		//0. new client
		LibYarnClient_t *client = NULL;
		int result = newLibYarnClient("postgres", rmHost, rmPort, schedHost, schedPort,
						amHost, amPort, am_tracking_url,&client,heartbeatInterval);
		printf("newLibYarnClient Result Code:%d\n",result);

		//1. createJob
		char *jobName = "libyarn";
		char *queue = "default";
		char *jobId = NULL;
		result = createJob(client, jobName, queue,&jobId);
		printf("1. createJob, jobid:%s The createJob Result Code:%d\n", jobId,result);
		if (result != FUNCTION_SUCCEEDED){
				const char* errorMessage = getErrorMessage();
				printf("1. createJob, errorMessage:%s\n",errorMessage);
		}


		char *blackListAdditions[0];
		char *blackListRemovals[0];

		//1. allocate resource
		LibYarnResource_t *allocatedResourcesArray;
		int allocatedResourceArraySize;
		result = allocateResources(client, jobId, 1, 1, 1024, 5,
								blackListAdditions, 0, blackListRemovals, 0, NULL, 0,
								&allocatedResourcesArray, &allocatedResourceArraySize);
		printf("The allocateResources Result Code:%d\n",result);
		if (result != FUNCTION_SUCCEEDED){
				const char* errorMessage = getErrorMessage();
				printf("2. allocateResources, errorMessage:%s\n",errorMessage);
		}

		int64_t activeContainerIds[allocatedResourceArraySize];
		int64_t releaseContainerIds[allocatedResourceArraySize];
		int64_t statusContainerIds[allocatedResourceArraySize];
		printf("2. allocateResources, allocatedResourceArraySize:%d\n", allocatedResourceArraySize);
		for (i = 0 ; i < allocatedResourceArraySize; i++) {
			puts("----------------------------");
			printf("allocatedResourcesArray[i].containerId:%ld\n", allocatedResourcesArray[i].containerId);
			activeContainerIds[i] = allocatedResourcesArray[i].containerId;
			releaseContainerIds[i] = allocatedResourcesArray[i].containerId;
			statusContainerIds[i] = allocatedResourcesArray[i].containerId;
			printf("allocatedResourcesArray[i].host:%s\n", allocatedResourcesArray[i].host);
			printf("allocatedResourcesArray[i].port:%d\n", allocatedResourcesArray[i].port);
			printf("allocatedResourcesArray[i].nodeHttpAddress:%s\n", allocatedResourcesArray[i].nodeHttpAddress);
			printf("allocatedResourcesArray[i].vCores:%d\n", allocatedResourcesArray[i].vCores);
			printf("allocatedResourcesArray[i].memory:%d\n", allocatedResourcesArray[i].memory);
		}

		//3. active
		result = activeResources(client, jobId, activeContainerIds,allocatedResourceArraySize);
		printf("The activeResources  Result Code:%d\n",result);
		if (result != FUNCTION_SUCCEEDED){
				const char* errorMessage = getErrorMessage();
				printf("2. activeResources, errorMessage:%s\n",errorMessage);
		}

		sleep(10);

		int64_t *activeFailIds;
		int activeFailSize;
		result = getActiveFailContainerIds(client,&activeFailIds,&activeFailSize);
		printf("Active Fail Container Size:%d\n",activeFailSize);
		for (i = 0;i < activeFailSize;i++){
				printf("Active Fail Container Id:%ld\n",activeFailIds[i]);
		}

		//4. getContainerReport
		LibYarnContainerReport_t *containerReportArray;
		int containerReportArraySize;
		result = getContainerReports(client, jobId, &containerReportArray,
				&containerReportArraySize);
		printf("The getContainerReports Result Code:%d\n", result);
		if (result != FUNCTION_SUCCEEDED) {
			const char* errorMessage = getErrorMessage();
			printf(" The getContainerReports, errorMessage:%s\n", errorMessage);
		}

		printf("containerReportArraySize=%d\n", containerReportArraySize);
		for (i = 0; i < containerReportArraySize; i++) {
			printf("-------------container: %d--------------------------\n", i);
			printf("containerId:%ld\n", containerReportArray[i].containerId);
			printf("vCores:%d\n", containerReportArray[i].vCores);
			printf("memory:%d\n", containerReportArray[i].memory);
			printf("host:%s\n", containerReportArray[i].host);
			printf("port:%d\n", containerReportArray[i].port);
			printf("exitStatus:%d\n", containerReportArray[i].exitStatus);
			printf("state:%d\n", containerReportArray[i].state);
		}
		freeContainerReportArray(containerReportArray, containerReportArraySize);

		//4. getContainerReport
		LibYarnContainerStatus_t *containerStatusArray;
		int containerStatusArraySize;
		result = getContainerStatuses(client, jobId, statusContainerIds,
				allocatedResourceArraySize, &containerStatusArray,
				&containerStatusArraySize);
		printf("The getContainerStatus Result Code:%d\n", result);
		if (result != FUNCTION_SUCCEEDED) {
			const char* errorMessage = getErrorMessage();
			printf(" The getContainerStatus, errorMessage:%s\n", errorMessage);
		}

		printf("containerStatusArraySize=%d\n", containerStatusArraySize);
		for (i = 0; i < containerStatusArraySize; i++) {
			printf("-------------container: %d--------------------------\n", i);
			printf("containerId:%ld\n", containerStatusArray[i].containerId);
			printf("exitStatus:%d\n", containerStatusArray[i].exitStatus);
			printf("state:%d\n", containerStatusArray[i].state);
			printf("diagnostics:%s\n", containerStatusArray[i].diagnostics);
		}
		freeContainerStatusArray(containerStatusArray,containerStatusArraySize);

		//6. getQueueInfo
		LibYarnQueueInfo_t *queueInfo = NULL;
		result = getQueueInfo(client, queue, true, true, true, &queueInfo);
		printf("The getQueueInfo  Result Code:%d\n",result);
		if (result != FUNCTION_SUCCEEDED){
				const char* errorMessage = getErrorMessage();
				printf(" The getQueueInfo, errorMessage:%s\n",errorMessage);
		}

		printf("QueueInfo: queueInfo->queueName:%s, queueInfo->capacity:%f, queueInfo->maximumCapacity:%f, queueInfo->currentCapacity:%f, queueInfo->state:%d\n",
				queueInfo->queueName, queueInfo->capacity, queueInfo->maximumCapacity,
				queueInfo->currentCapacity, queueInfo->state);
		puts("---------chilldQueue:");
		for (i = 0; i < queueInfo->childQueueNameArraySize; i++) {
				printf("QueueInfo: queueInfo->childQueueNameArray[%d]:%s\n", i, queueInfo->childQueueNameArray[i]);
		}
		freeMemQueueInfo(queueInfo);

		//7. getCluster
		LibYarnNodeReport_t *nodeReportArray;
		int nodeReportArraySize;
		result = getClusterNodes(client, NODE_STATE_RUNNING, &nodeReportArray, &nodeReportArraySize);
		printf("The getClusterNodes Result Code:%d\n",result);
		if (result != FUNCTION_SUCCEEDED){
				const char* errorMessage = getErrorMessage();
				printf(" The getClusterNodes, errorMessage:%s\n",errorMessage);
		}

		printf("nodeReportArraySize=%d\n", nodeReportArraySize);
		for (i = 0; i < nodeReportArraySize; i++) {
			printf("-------------node %d--------------------------\n", i);
			printf("host:%s\n", nodeReportArray[i].host);
			printf("port:%d\n", nodeReportArray[i].port);
			printf("httpAddress:%s\n", nodeReportArray[i].httpAddress);
			printf("rackName:%s\n", nodeReportArray[i].rackName);
			printf("memoryUsed:%d\n", nodeReportArray[i].memoryUsed);
			printf("vcoresUsed:%d\n", nodeReportArray[i].vcoresUsed);
			printf("memoryCapability:%d\n", nodeReportArray[i].memoryCapability);
			printf("vcoresCapability:%d\n", nodeReportArray[i].vcoresCapability);
			printf("numContainers:%d\n", nodeReportArray[i].numContainers);
			printf("nodeState:%d\n", nodeReportArray[i].nodeState);
			printf("healthReport:%s\n", nodeReportArray[i].healthReport);
			printf("lastHealthReportTime:%lld\n", nodeReportArray[i].lastHealthReportTime);
		}
		freeMemNodeReportArray(nodeReportArray, nodeReportArraySize);

		//8. getApplicationReport
		LibYarnApplicationReport_t *applicationReport = NULL;
		result = getApplicationReport(client, jobId, &applicationReport);
		printf("The getApplicationReport  Result Code:%d\n", result);
		if (result != FUNCTION_SUCCEEDED) {
			const char* errorMessage = getErrorMessage();
			printf(" The getApplicationReport, errorMessage:%s\n",
					errorMessage);
		}
		printf("-------------ApplicationReport-------------------------\n");
		printf("appId:%d\n", applicationReport->appId);
		printf("user:%s\n",  applicationReport->user);
		printf("queue:%s\n", applicationReport->queue);
		printf("name:%s\n", applicationReport->name);
		printf("host:%s\n", applicationReport->host);
		printf("port:%d\n", applicationReport->port);
		printf("status:%d\n", applicationReport->status);

		freeApplicationReport(applicationReport);

		//5. release
		result = releaseResources(client, jobId, releaseContainerIds,allocatedResourceArraySize);
		printf("The releaseResources  Result Code:%d\n",result);

		result = getActiveFailContainerIds(client,&activeFailIds,&activeFailSize);
		printf("Active Fail Container Size:%d\n",activeFailSize);
		for (i = 0;i < activeFailSize;i++){
			printf("Active Fail Container Id:%d\n",activeFailIds[i]);
		}
		free(activeFailIds);
		freeMemAllocatedResourcesArray(allocatedResourcesArray, allocatedResourceArraySize);
		printf("freeMemAllocated is OK\n");

		//9. finish
		printf("jobId:%s\n", jobId);
		result = finishJob(client, jobId, APPLICATION_SUCCEEDED);
		printf("The finishJob Result Code:%d\n", result);
		if (result != FUNCTION_SUCCEEDED) {
			const char* errorMessage = getErrorMessage();
			printf(" The finishJob, errorMessage:%s\n", errorMessage);
		}
		free(jobId);
		//10. free client
		deleteLibYarnClient(client);

		return 0;
}