/**
 * @brief               Reads the current state of a gpio pin.
 * @param gpioNumber    The number of the GPIO pin to read.
 * @param[out] state    Pointer to the variable in which the GPIO pin state is 
 *                      returned.
 * @return              An error from #errStatus. */
errStatus gpioReadPin(int gpioNumber, eState * state)
{ 
    errStatus rtn = ERROR_DEFAULT;

    if (gGpioMap == NULL)
    {
        dbgPrint(DBG_INFO, "gGpioMap was NULL. Ensure gpioSetup() was called successfully.");
        rtn = ERROR_NULL;
    }
    
    else if ((rtn = gpioValidatePin(gpioNumber)) != OK)
    {
        dbgPrint(DBG_INFO, "gpioValidatePin() failed. Pin %d isn't valid.", gpioNumber);
    }
    
    else 
    {
        /* Check if the appropriate bit is high */
        if (GPIO_GPLEV0 & (0x1 << gpioNumber))
        {
            *state = high;
        }

        else
        {
            *state = low;
        }

        rtn = OK;
    }   

    return rtn;
}

/*
 * ::openEvents
 */
BOOL openEvents(HANDLE *outEvtDebugee, HANDLE *outEvtDebugger) {
#define EVENT_NAME_LEN (32)
#define SHMEM_NAME_LEN (64)

    wchar_t eventName[EVENT_NAME_LEN];
    DWORD processId = 0;

    /* Sanity checks. */
    if ((outEvtDebugee == NULL) || (outEvtDebugger == NULL)) {
        return TRUE;
    }

    /* TODO: Possible hazard when using multiple instances simultanously. */
    processId = GetCurrentProcessId();

    _snwprintf(eventName, EVENT_NAME_LEN, L"%udbgee", processId);
    if ((*outEvtDebugee = OpenEventW(EVENT_ALL_ACCESS, FALSE, eventName)) 
            == NULL) {
        dbgPrint(DBGLVL_ERROR, "OpenEvent(\"%s\") failed: %u.\n",
		          eventName, GetLastError());
        return FALSE;
    }

    _snwprintf(eventName, EVENT_NAME_LEN, L"%udbgr", processId);
    if ((*outEvtDebugger = OpenEventW(EVENT_ALL_ACCESS, FALSE, eventName)) 
            == NULL) {
        dbgPrint(DBGLVL_ERROR, "OpenEvent(\"%s\") failed: %u.\n",
		         eventName, GetLastError());
        return FALSE;
    }

    return TRUE;
#undef EVENT_NAME_LEN
}

static void getUnusedNameByPrefix(char **name, ShVariableList *vl,
		const char *prefix)
{
	if (!(findFirstShVariableFromName(vl, prefix))) {
		/* name is free to use */
		if (!(*name = (char*) malloc(strlen(prefix) + 1))) {
			dbgPrint(DBGLVL_ERROR,
					"CodeInsertion - not enough memory for result name\n");
			exit(1);
		}
		strcpy(*name, prefix);
	} else {
		/* add randomized post-fix to name until its free */
		if (!(*name = (char*) malloc(
				strlen(prefix) + 1 + CG_RANDOMIZED_POSTFIX_SIZE))) {
			dbgPrint(DBGLVL_ERROR,
					"CodeInsertion - not enough memory for result name\n");
			exit(1);
		}
		strcpy(*name, prefix);

		while (findFirstShVariableFromName(vl, *name)) {
			char ran;
			int i;

			(*name)[strlen(prefix)] = '\0';

			for (i = 0; i < CG_RANDOMIZED_POSTFIX_SIZE; i++) {
				ran = (char) ((rand() / (float) RAND_MAX) * ('Z' - 'A') + 'A');
				strncat(*name, &ran, 1);
			}
		}
	}
}

/**
 * @brief               Sets the functionality of the desired pin.
 * @param gpioNumber    The gpio pin number to change.
 * @param function      The desired functionality for the pin. 
 * @return              An error from #errStatus. */
errStatus gpioSetFunction(int gpioNumber, eFunction function)
{
    errStatus rtn = ERROR_DEFAULT;

    if (gGpioMap == NULL)
    {
        dbgPrint(DBG_INFO, "gGpioMap was NULL. Ensure gpioSetup() called successfully.");
        rtn = ERROR_NULL;
    }

    else if (function < eFunctionMin || function > eFunctionMax)
    {
        dbgPrint(DBG_INFO, "eFunction was out of range. %d", function);
        rtn = ERROR_RANGE;
    }
    
    else if ((rtn = gpioValidatePin(gpioNumber)) != OK)
    {
        dbgPrint(DBG_INFO, "gpioValidatePin() failed. Ensure pin %d is valid.", gpioNumber);
    }

    else
    {
        /* Clear what ever function bits currently exist - this puts the pin 
         * into input mode.*/
        *(gGpioMap + (gpioNumber / 10)) &= ~(GPFSEL_BITS << ((gpioNumber % 10) * 3));

        /* Set the three pins for the pin to the desired value */
        *(gGpioMap + (gpioNumber / 10)) |=  (function << ((gpioNumber % 10) * 3));

        rtn = OK;
    }

    return rtn;
}

/*
 * ::openSharedMemory
 */
BOOL openSharedMemory(HANDLE *outShMem, void **outBaseAddr, const int size) {
#define SHMEM_NAME_LEN (64)

    char shMemName[SHMEM_NAME_LEN];

    if (!GetEnvironmentVariableA("GLSL_DEBUGGER_SHMID", shMemName, 
            SHMEM_NAME_LEN)) {
        dbgPrint(DBGLVL_ERROR, "Oh Shit! No Shmid! Set GLSL_DEBUGGER_SHMID.\n");
        return FALSE;
    }

    /* This creates a non-inheritable shared memory mapping! */
    *outShMem = OpenFileMappingA(FILE_MAP_WRITE, FALSE, shMemName);
    if ((*outShMem == NULL) || (*outShMem == INVALID_HANDLE_VALUE)) {
        dbgPrint(DBGLVL_ERROR, "Opening of shared mem segment \"%s\" failed: %u.\n", 
            shMemName, GetLastError());
        return FALSE;
    }
    
    /* FILE_MAP_WRITE implies read */
    *outBaseAddr = MapViewOfFile(*outShMem, FILE_MAP_WRITE, 0, 0, size);
    if (*outBaseAddr == NULL) {
        dbgPrint(DBGLVL_ERROR, "View mapping of shared mem segment \"%s\" failed: %u.\n",
            shMemName, GetLastError());
        CloseHandle(*outShMem);
        return FALSE;
    }

    return TRUE;
#undef SHMEM_NAME_LEN
}

bool isChildofMain(TIntermNode *node, TIntermNode *root)
{
    TIntermNode *main = getFunctionBySignature(MAIN_FUNC_SIGNATURE, root);

    if (!main) {
        dbgPrint(DBGLVL_ERROR, "CodeTools - could not find main function\n");
        exit(1);
    }

    TIntermAggregate *aggregate;

    if (!(aggregate = main->getAsAggregate())) {
        dbgPrint(DBGLVL_ERROR, "CodeTools - main is not Aggregate\n");
        exit(1);
    }
    
    TIntermSequence sequence = aggregate->getSequence();
    TIntermSequence::iterator sit;

    for(sit = sequence.begin(); sit != sequence.end(); sit++) {
        if (*sit == node) {
            return true;
        }
    }

    return false;
}

TType* getTypeDebugParameter(TIntermAggregate *node, int pnum)
{
	TType *result = NULL;

	if (!node)
		return result;

	if (node->getOp() != EOpFunctionCall)
		return result;

	TIntermSequence funcCallSeq = node->getSequence();

	if ((int) funcCallSeq.size() < pnum) {
		dbgPrint(DBGLVL_ERROR,
				"CodeTools -  function does not have this much parameter\n");
		exit(1);
	}

	if (!funcCallSeq[pnum]->getAsTyped()) {
		dbgPrint(DBGLVL_ERROR,
				"CodeTools -  in parameter is not of type TIntermTyped\n");
		exit(1);
	}

	return funcCallSeq[pnum]->getAsTyped()->getTypePointer();
}

static void dumpAstChangeableList(exec_list *cl)
{
	if (!cl)
		return;
	dbgPrint(DBGLVL_INFO, "===> ");
	if (cl->is_empty())
		dbgPrint(DBGLVL_INFO, "empty");
	foreach_in_list(changeable_item, item, cl) {
		dumpShChangeable(item->changeable);
	}

void ShVarItem::setCurrentPointer(VertexBox *vb)
{
	if (vb) {
		dbgPrint(DBGLVL_DEBUG,
				"setCurrentPointer: VertexBox %p numVertices=%i data=%p\n", vb, vb->getNumVertices(), vb->getDataPointer());
	} else {
		dbgPrint(DBGLVL_DEBUG, "setCurrentPointer: NULL\n");
	}
	setData(DF_DATA_CURRENTBOX, QVariant::fromValue<void*>((void*) vb));
}

/**
 * Free the library designated by 'hRemoteModule' in process 'hProcess'.
 */
static bool RemoteFreeLibrary(HANDLE hProcess, HANDLE hRemoteModule) {
    bool retval = false;            // Result of overall operation.
    DWORD exitCode = 0;             // Exit code of remote thread.
    HANDLE hThread = NULL;          // Handle to remote thread.
    HMODULE hKernel32 = NULL;       // Module handle of kernel32.dll.
    FARPROC freeLibrary = NULL;     // Function pointer of LoadLibrary.
    
    /* Sanity checks. */
    if (hProcess == NULL) {
        goto cleanup;
    }
    if (hRemoteModule == NULL) {
        goto cleanup;
    }

    /* Get Function pointer to LoadLibrary. */
    if ((hKernel32 = ::GetModuleHandleA("kernel32")) == NULL) {
        dbgPrint(DBGLVL_ERROR, "Module handle of \"kernel32\" could not be retrieved: "
            "%u.\n", ::GetLastError());
        goto cleanup;
    }
    if ((freeLibrary = ::GetProcAddress(hKernel32, "FreeLibrary")) == NULL) {
        dbgPrint(DBGLVL_ERROR, "\"FreeLibrary\" could not be found: %u.\n",
            ::GetLastError());
        goto cleanup;
    }

    /* Unload the debug library from the remote process. */
    if ((hThread = ::CreateRemoteThread(hProcess, NULL, 0, 
            reinterpret_cast<LPTHREAD_START_ROUTINE>(freeLibrary), 
            reinterpret_cast<void *>(hRemoteModule), 0, NULL)) == NULL) {
        goto cleanup;
    }

    /* Wait for FreeLibrary to complete. */
    if (::WaitForSingleObject(hThread, INFINITE) != WAIT_OBJECT_0) {
        dbgPrint(DBGLVL_ERROR, "WaitForSingleObject failed: %u.\n", ::GetLastError());
        goto cleanup;
    }
    
    /* Get exit code, which is the result of remote FreeLibrary. */
    if (!::GetExitCodeThread(hThread, &exitCode)) {
        dbgPrint(DBGLVL_ERROR, "GetExitCodeThread failed: %u.\n", ::GetLastError());
        goto cleanup;
    }
    retval = (exitCode != 0);

    /* Clean up. */
cleanup:
    if (hThread != NULL) {
        ::CloseHandle(hThread);
    }

    return retval;
}

PixelBox* ShVarItem::getPixelBoxPointer(void)
{
	QVariant v = data(DF_DATA_PIXELBOX);
	if (v.value<void*>() == NULL) {
		dbgPrint(DBGLVL_DEBUG, "getPixelBoxPointer: PixelBox not set\n");
		return NULL;
	} else {
		dbgPrint(DBGLVL_DEBUG,
				"getPixelBoxPointer: PixelBox %p\n", v.value<void*>());
		return (PixelBox*) v.value<void*>();
	}
}

/**
 * @brief   Disables the I2C controller and unmaps the memory used for the
 *          i2c functionality. This function should be called when finished
 *          with the I2C module.
 * @return  An error from #errStatus. */
errStatus gpioI2cCleanup(void)
{
    errStatus rtn = ERROR_DEFAULT;
    int sda;
    int scl;

    if (gI2cMap == NULL)
    {
        dbgPrint(DBG_INFO, "gI2cMap was NULL. Ensure gpioI2cSetup() was called successfully.");
        rtn = ERROR_NOT_INITIALISED;
    }

    else if ((rtn = gpioGetI2cPins(&scl, &sda)) != OK)
    {
        dbgPrint(DBG_INFO, "gpioGetI2cPins() failed. %s",
                 gpioErrToString(rtn));
    }

    /* Set SDA pin to input */
    else if ((rtn = gpioSetFunction(sda, input)) != OK)
    {
        dbgPrint(DBG_INFO, "gpioSetFunction() failed for SDA. %s",
                 gpioErrToString(rtn));
    }

    /* Set SCL pin to input */
    else if ((rtn = gpioSetFunction(scl, input)) != OK)
    {
        dbgPrint(DBG_INFO, "gpioSetFunction() failed for SCL. %s",
                gpioErrToString(rtn));
    }

    else
    {
        /* Disable the BSC Controller */
        I2C_C &= ~BSC_I2CEN;

        /* Unmap the memory */
        if (munmap((void *)gI2cMap, I2C_MAP_SIZE) != OK)
        {
            dbgPrint(DBG_INFO, "mummap() failed. errno: %s.", strerror(errno));
            rtn = ERROR_EXTERNAL;
        }

        else
        {
            gI2cMap = NULL;
            rtn = OK;
        }
    }

    return rtn;
}

/* TODO: error checking */
static int attachShaderObject(GLint programHandle, GLenum type, const char *src)
{
	GLint shader, status;
	int error;

	dbgPrint(DBGLVL_COMPILERINFO,
	         "ATTACH SHADER: %s\n-----------------\n%s\n--------------\n",
	         lookupEnum(type), src);

	shader = ORIG_GL(glCreateShader)(type);
	error = glError();
	if (error) {
		return error;
	}
	ORIG_GL(glShaderSource)(shader, 1, (void*)&src, NULL);
	error = glError();
	if (error) {
		return error;
	}
	ORIG_GL(glCompileShader)(shader);
	 error = glError();
	if (error) {
		return error;
	}
	ORIG_GL(glGetShaderiv)(shader, GL_COMPILE_STATUS, &status);
	error = glError();
	if (error) {
		return error;
	}
	printShaderInfoLog(shader);
	error = glError();
	if (error) {
		return error;
	}
	if (!status) {
		dbgPrint(DBGLVL_ERROR, "DBG SHADER COMPILATION for %s failed!\n", lookupEnum(type));
		return DBG_ERROR_DBG_SHADER_COMPILE_FAILED;
	}
	ORIG_GL(glAttachShader)(programHandle, shader);
	error = glError();
	if (error) {
		return error;
	}
	ORIG_GL(glDeleteShader)(shader);
	error = glError();
	if (error) {
		return error;
	}
	return DBG_NO_ERROR;
}

void ProgramControl::closeEvents(void) {
	dbgPrint(DBGLVL_INFO, "Closing events ...\n");

	if (_hEvtDebugger != NULL) {
		::CloseHandle(_hEvtDebugger);
		_hEvtDebugger = NULL;
	}

	if (_hEvtDebuggee != NULL) {
		::CloseHandle(_hEvtDebuggee);
		_hEvtDebuggee = NULL;
	}

	dbgPrint(DBGLVL_INFO, "Events closed.\n");
}

PPClsPack* PPAppReceiver::proxy_hello(PPClsPack& args) {
	dbgPrint(0, "calling proxyhello");

 	int* iArg = (int*)args(0).getData();
	dbgPrint(0, "data=%d", *iArg);
	dumpCharArray((char*)iArg);
	dumpCharArray(args(0).getData());
	*iArg *= -1;

	PPClsPack argRet(1);
	argRet(0) <<= PPFunPack(4, (char*)iArg);

	sendFn(argRet);
	dbgPrint(0, "proxyhello ended");
}

static unsigned long __stdcall _thread(void* _args) {
    SYSTEMTIME st = {0};

    while (1) {
        if (g_isQuit)
            break;
        GetLocalTime(&st);
        dbgPrint("Now time is : %.2d:%.2d:%.2d:%.3d", 
            st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);

        Sleep(100);
    }
    g_isQuit = 0;
    dbgPrint("the thread quit in safe way ...");
    return 0L;
}

/* TODO: error checking */
static void printProgramInfoLog(GLhandleARB shader)
{
	int length;
	GLcharARB *log;

	ORIG_GL(glGetProgramiv)(shader, GL_INFO_LOG_LENGTH, &length);
	if (length > 1) {
		if (!(log = (GLcharARB*)malloc(length*sizeof(GLcharARB)))) {
			dbgPrint(DBGLVL_ERROR, "Allocation of mem for GLSL info log failed\n");
			exit(1);
		}
		ORIG_GL(glGetProgramInfoLog)(shader, length, NULL, log);
		dbgPrint(DBGLVL_INFO, "PROGRAM INFOLOG:\n%s\n", log);
		free(log);
	}
}

bool PixelBox::isAllDataAvailable()
{
	int x, y;
	bool *pDataMap;
	bool *pCoverage;

	if (!m_pDataMap) {
		return false;
	}

	pDataMap = m_pDataMap;
	pCoverage = m_pCoverage;

	for (y = 0; y < m_nHeight; y++) {
		for (x = 0; x < m_nWidth; x++) {
			if (*pCoverage && !*pDataMap) {
				dbgPrint(DBGLVL_INFO,
						"NOT ALL DATA AVILABLE, NEED READBACK =========================\n");
				return false;
			}
			pDataMap++;
			pCoverage++;
		}
	}
	return true;
}

	/* Copy appropriate bytes out of the buffer.  */
	memcpy (dst, (char*)buffer + ((ALIGNED_DATA)src & (sizeof(ALIGNED_DATA) - 1)), size);
	
	free(buffer);
}
#endif /* _WIN32 */

#ifdef _WIN32
void cpyToProcess(DWORD pid, void *dst, void *src, size_t size) {
	SIZE_T numBytesWritten;
	HANDLE procHandle = OpenProcess(PROCESS_VM_WRITE | PROCESS_VM_OPERATION, FALSE, pid);
	if (procHandle == NULL) {
		dbgPrint(DBGLVL_ERROR, "cpyToProcess: could not open process %u\n", procHandle);
		exit(1);
	}
	if (WriteProcessMemory(procHandle, dst, src, size, &numBytesWritten) == 0) {
		dbgPrint(DBGLVL_ERROR, "cpyToProcess: copying failed: %u\n", GetLastError());
		CloseHandle(procHandle);
		exit(1);
	}
	if (numBytesWritten != size) {
		dbgPrint(DBGLVL_ERROR, "cpyToProcess: could copy only %u out of %u bytes.\n", numBytesWritten, size);
		CloseHandle(procHandle);
		exit(1);
	}
	CloseHandle(procHandle);
}
#else /* _WIN32 */
void cpyToProcess(pid_t pid, void *dst, void *src, size_t size)
{
	ALIGNED_DATA start, *buffer;
	size_t count;
	int i;
    
	/* Round starting address down to word boundary */
	start = (ALIGNED_DATA)dst & -(ALIGNED_DATA)sizeof(ALIGNED_DATA);
	
	/* number of words to copy */
	count = ((((ALIGNED_DATA)dst + size) - start) + sizeof(ALIGNED_DATA) - 1)/sizeof(ALIGNED_DATA);
		
	buffer = (ALIGNED_DATA*)malloc(count*sizeof(ALIGNED_DATA));
	if (!buffer) {
		dbgPrint(DBGLVL_ERROR, "cpyFromProcess: Could not allocate buffer\n");
		exit(1);
	}
	
	/* fill extra bytes at start and end of buffer with existing data */
	buffer[0] = ptrace(PTRACE_PEEKTEXT, pid, (void*)start, 0);
	if (count > 1) {
		buffer[count - 1] = ptrace(PTRACE_PEEKTEXT, pid,
	                               (void*)(start + (count - 1)*sizeof(ALIGNED_DATA)), 0);
    }

	/* copy data */
	memcpy ((char*)buffer + ((ALIGNED_DATA)dst & (sizeof(ALIGNED_DATA) - 1)), src, size);

	/* write buffer */
	for (i = 0; i < count; i++) {
		ptrace(PTRACE_POKETEXT, pid, (void*)start, buffer[i]);
		start += sizeof(ALIGNED_DATA);
	}
	free(buffer);
}

int getFunctionDebugParameter(TIntermAggregate *node)
{
    int result = -1;
    int i;

    if (!node)
        return result;

    if ( node->getOp() != EOpFunction) {
        return result;
    }

    TIntermSequence funcDeclSeq = node->getSequence();
    
    if (!funcDeclSeq[0] ||
        !funcDeclSeq[0]->getAsAggregate() ||
        !(funcDeclSeq[0]->getAsAggregate()->getOp() == EOpParameters)) {
        dbgPrint(DBGLVL_ERROR, "CodeTools - function does not comply with assumptions\n");
        exit(1);
    }
    TIntermSequence funcDeclParamSeq = (funcDeclSeq[0]->getAsAggregate())->getSequence();
    TIntermSequence::iterator pD = funcDeclParamSeq.begin();
    
    for (i=0; pD != funcDeclParamSeq.end(); ++pD, ++i) {
        if ((*pD)->getAsFuncParamNode()->getType().getQualifier() == EvqIn) {
            result = i;
        }
    }

    return result;
}