#define BOOST_PYTHON_STATIC_LIB
#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
#include <boost/python.hpp>
#include <string>
#include <sstream>
#include <vector>
#include <iostream>
#include "HAPI.h"


#define ENSURE_SUCCESS( result ) \
if ( (result) != HAPI_RESULT_SUCCESS ) \
{ \
    std::cout << "Failure at " << __FILE__ << ": " << __LINE__ << std::endl; \
    std::cout << getLastError() << std::endl; \
    exit( 1 ); \
}

#define ENSURE_COOK_SUCCESS( result ) \
if ( (result) != HAPI_RESULT_SUCCESS ) \
{ \
    std::cout << "Failure at " << __FILE__ << ": " << __LINE__ << std::endl; \
    std::cout << getLastCookError() << std::endl; \
    exit( 1 ); \
}

static std::string getLastError();
static std::string getLastCookError();

using namespace boost::python;


std::string 
set_list(list& python_list) {
	std::vector<double> list_items;

	for (int i = 0; i < len(python_list); ++i) {
		double item = extract<double>(python_list[i]);
		list_items.push_back(item);
	}

	std::ostringstream info;

	auto it = list_items.begin();
	while (it != list_items.end()) {
		info << *it;
		++it;
	}

	return info.str();
}

void 
usd_to_he(list& position_list, list& vertex_list, list& facecounts)
{
	
	HAPI_Session session;
	// HAPI_CreateThriftNamedPipeSession(&session, "hapi");
	HAPI_CreateInProcessSession(&session);
	HAPI_CookOptions cook_options = HAPI_CookOptions_Create();	
	HAPI_Initialize(&session, &cook_options, true, -1, nullptr, nullptr, nullptr, nullptr, nullptr);
	

	/*HAPI_NodeId lop_node;
	HAPI_Result	result = HAPI_CreateNode(&session, -1, "Sop/usdexport", nullptr, true, &lop_node);*/


	HAPI_NodeId input_node;		
	ENSURE_SUCCESS(HAPI_CreateInputNode(&session, &input_node, "input"));
	//ENSURE_SUCCESS(HAPI_CookNode(&session, input_node, &cook_options));	
	//int cookStatus;
	//HAPI_Result cookResult;
	//do
	//{
	//	cookResult = HAPI_GetStatus(&session, HAPI_STATUS_COOK_STATE, &cookStatus);
	//} while (cookStatus > HAPI_STATE_MAX_READY_STATE && cookResult == HAPI_RESULT_SUCCESS);
	//ENSURE_SUCCESS(cookResult);
	//ENSURE_COOK_SUCCESS(cookStatus);


	HAPI_PartInfo part_info = HAPI_PartInfo_Create();	
	part_info.faceCount = int(len(facecounts));
	part_info.pointCount = int(len(position_list)/3);
	part_info.vertexCount = int(len(vertex_list));
	part_info.type = HAPI_PARTTYPE_MESH;	
	ENSURE_SUCCESS(HAPI_SetPartInfo(&session, input_node, 0, &part_info));
	std::cout << "partinfo" << std::endl;

	HAPI_AttributeInfo attrinfo = HAPI_AttributeInfo_Create();
	attrinfo.count = part_info.pointCount;
	attrinfo.exists = true;
	attrinfo.owner = HAPI_ATTROWNER_POINT;
	attrinfo.storage = HAPI_STORAGETYPE_FLOAT;
	attrinfo.tupleSize = 3;
	HAPI_AddAttribute(&session, input_node, 0, "P", &attrinfo);
	std::cout << "attrinfo" << std::endl;
	
	std::vector<float> position_list_usd(part_info.pointCount * 3); 
	for (int i = 0; i < len(position_list)/3; i++) {			// py list -> cpp vector
		float posx = extract<float>(position_list[0 + i * 3]);
		float posy = extract<float>(position_list[1 + i * 3]);
		float posz = extract<float>(position_list[2 + i * 3]);
		position_list_usd[0 + i * 3] = posx;
		position_list_usd[1 + i * 3] = posy;
		position_list_usd[2 + i * 3] = posz;		
	}
	HAPI_SetAttributeFloatData(&session, input_node, 0, "P", &attrinfo, position_list_usd.data(), 0, part_info.pointCount);
	std::cout << "set pos" << std::endl;

	std::vector<int> vertex_list_usd(part_info.vertexCount * 3);
	for (int i = 0; i < len(vertex_list); i++) {		// py list -> cpp vector
		int item = extract<int>(vertex_list[i]);		
		// vertex_list_usd[i] = item;  error
		vertex_list_usd.push_back(item);
	}
	HAPI_SetVertexList(&session, input_node, 0, vertex_list_usd.data(), 0, part_info.vertexCount);
	std::cout << "set vertex" << std::endl;

	std::vector<int> facecounts_usd(part_info.faceCount);
	for (int i = 0; i < len(facecounts); i++) {			// py list -> cpp vector
		int item = extract<int>(facecounts[i]);
		facecounts_usd.push_back(item);
	}
	HAPI_SetFaceCounts(&session, input_node, 0, facecounts_usd.data(), 0, part_info.faceCount);
	std::cout << "set face"<< std::endl;

	HAPI_CommitGeo(&session, input_node);
	std::cout << "commit geo"<< std::endl; 

	ENSURE_SUCCESS( HAPI_SaveHIPFile(&session, "C:/Users/Administrator/Desktop/he_test.hip", 0) );
	HAPI_Cleanup(&session);
}


BOOST_PYTHON_MODULE(he_usd) {	
	def("set_list", set_list);
	def("usd_to_he", usd_to_he);
}

static std::string
getLastError()
{
	int bufferLength;
	HAPI_GetStatusStringBufLength(nullptr,
		HAPI_STATUS_CALL_RESULT,
		HAPI_STATUSVERBOSITY_ERRORS,
		&bufferLength);

	char * buffer = new char[bufferLength];

	HAPI_GetStatusString(nullptr, HAPI_STATUS_CALL_RESULT, buffer, bufferLength);

	std::string result(buffer);
	delete[] buffer;

	return result;
}

static std::string
getLastCookError()
{
	int bufferLength;
	HAPI_GetStatusStringBufLength(nullptr,
		HAPI_STATUS_COOK_RESULT,
		HAPI_STATUSVERBOSITY_ERRORS,
		&bufferLength);

	char * buffer = new char[bufferLength];

	HAPI_GetStatusString(nullptr, HAPI_STATUS_COOK_RESULT, buffer, bufferLength);

	std::string result(buffer);
	delete[] buffer;

	return result;
}