//设置事件
bool CRequestSocket::SetEventService(IUnknownEx * pIUnknownEx)
{
	GT_ASSERT(pIUnknownEx!=NULL);
	m_pIEventService=GET_OBJECTPTR_INTERFACE(pIUnknownEx,IEventService);
	GT_ASSERT(m_pIEventService!=NULL);
	return (m_pIEventService!=NULL);
}

//开始服务
bool __cdecl CQueueService::StartService(BYTE cbThreadCount)
{
	//效验参数
	GT_ASSERT(m_bService==false);
	GT_ASSERT(m_hCompletionPort==NULL);
	GT_ASSERT(m_pIQueueServiceSink!=NULL);

	m_cbThreadCount = cbThreadCount;

	m_hCompletionPort	 = new HANDLE[m_cbThreadCount];
	memset(m_hCompletionPort, 0, sizeof(HANDLE) * m_cbThreadCount);
	m_QueueServiceThread = new CQueueServiceThread[m_cbThreadCount];

	for(BYTE i = 0; i < m_cbThreadCount; i ++)
	{
		//建立完成端口
		m_hCompletionPort[i]=CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,NULL,1);
		if (m_hCompletionPort[i]==NULL) throw TEXT("队列对象完成端口创建失败");

		//启动线程
		if (m_QueueServiceThread[i].InitThread(m_hCompletionPort[i], i)==false) throw TEXT("队列对象线程初始化失败");
		if (m_QueueServiceThread[i].StartThead()==false) throw TEXT("队列对象线程启动失败");

	}

	//设置参数
	m_bService=true;

	return true;
}

bool __cdecl CCalculateSink::InitCalculateSink(ITableFrame	*pITableFrame,
											   CTableFrameSink *pTableFrameSink)
{
	m_pITableFrame=pITableFrame;
	if (m_pITableFrame==NULL) return false;

	m_pTableFrameSink = pTableFrameSink;
	GT_ASSERT(m_pTableFrameSink != NULL);

	//获取参数
	m_pGameServiceAttrib=m_pITableFrame->GetGameServiceAttrib();
	GT_ASSERT(m_pGameServiceAttrib!=NULL);

	m_pGameServiceOption=m_pITableFrame->GetGameServiceOption();
	GT_ASSERT(m_pGameServiceOption!=NULL);

	m_pICalculateFrame = m_pITableFrame->GetICalculateFrame();
	GT_ASSERT(m_pICalculateFrame != NULL);

	memset(&m_decAfterTax, 0, sizeof(DECIMAL));
	DECIMAL decTemp;
	memset(&decTemp, 0, sizeof(DECIMAL));
	VarDecFromI4(-1, &decTemp);
	VarDecMul(&decTemp,(DECIMAL*) &m_pGameServiceOption->decTaxRate, &m_decAfterTax);

	return true;
}

HRESULT
CaPerfDataWriter::writeFakeTimerInfo(caperf_section_fake_timer_t* pInfo)
{
    HRESULT ret = E_FAIL;

    if ((!pInfo)
        || (0 == pInfo->numCpu)
        || (0 == pInfo->timerNanosec)
        || (NULL == pInfo->timerFds)
        || (NULL == pInfo->fakeTimerFds))
    {
        return ret;
    }

    m_offset = lseek(m_fd, 0, SEEK_END);
    ssize_t sectionStOffset = m_offset;

    // Following the structure of caperf_section_fake_timer
    ssize_t rc = write(m_fd, (const void*) &pInfo->numCpu, sizeof(gtUInt32));
    GT_ASSERT(rc != -1);
    rc = write(m_fd, (const void*) &pInfo->timerNanosec, sizeof(gtUInt32));
    GT_ASSERT(rc != -1);
    rc = write(m_fd, (const void*) pInfo->timerFds, sizeof(gtUInt32) * pInfo->numCpu);
    GT_ASSERT(rc != -1);
    rc = write(m_fd, (const void*) pInfo->fakeTimerFds, sizeof(gtUInt32) * pInfo->numCpu);
    GT_ASSERT(rc != -1);

    m_offset = lseek(m_fd, 0, SEEK_CUR);

    // update the section header entry
    updateSectionHdr(CAPERF_SECTION_FAKE_TIMER_INFO, sectionStOffset, (m_offset - sectionStOffset));

    ret = S_OK;
    return ret;
}

//设置异步
bool CCenterSocket::SetAsynchronismEngine(IUnknownEx * pIUnknownEx)
{
	GT_ASSERT(pIUnknownEx!=NULL);
	m_pIAsynchronismEngine=GET_OBJECTPTR_INTERFACE(pIUnknownEx,IAsynchronismEngine);
	GT_ASSERT(m_pIAsynchronismEngine!=NULL);
	return (m_pIAsynchronismEngine!=NULL);
}

bool GraphicsServerCommunication::GetCurrentFrameInfo(gtASCIIString& frameInfoAsXML, unsigned char*& pImageBuffer, unsigned long& imageSize)
{
    bool retVal = true;
    OS_DEBUG_LOG_TRACER_WITH_RETVAL(retVal);

    gtASCIIString httpRtnString;
    gtASCIIString commandPrefix = m_strApiHttpCommand;
    retVal = SendCommandPid(commandPrefix.append("/PushLayer=FrameDebugger"), httpRtnString, "");
    GT_ASSERT(retVal);

    if (retVal)
    {
        commandPrefix = m_strApiHttpCommand;
        // Send a request to get the current frame info
        retVal = SendCommandPid(commandPrefix.append("/FD/GetCurrentFrameInfo.xml"), frameInfoAsXML, "");
        GT_ASSERT(retVal);

        if (retVal)
        {
            commandPrefix = m_strApiHttpCommand;
            // Send a request to get the current frame thumbnail
            retVal = SendCommandWithBinaryData(commandPrefix.append("/FD/GetFrameBufferImage.png?width=512?height=512"), pImageBuffer, imageSize);

            if (retVal)
            {
                PopLayer();
            }
        }
    }

    return retVal;
}

bool __cdecl CRequestSocket::OnSocketServerRequest(CMD_Command Command, void * pBuffer, WORD wDataSize)
{
	switch(Command.wSubCmdID) 
	{
	case SUB_CS_GET_LOADERSERVERINFO_SUCCESS:
		{

			GT_ASSERT(wDataSize >= sizeof(CMD_CS_LoaderServerInfo));

			CMD_CS_LoaderServerInfo *pInfo = (CMD_CS_LoaderServerInfo*)pBuffer;
			GT_ASSERT(m_pIEventService!=NULL);
			TCHAR szDescribe[128]=TEXT("");
			_snprintf(szDescribe,sizeof(szDescribe),TEXT("【服务ID %ld】请求登陆信息成功"),(LONG)m_pInitParamter->m_wServerID);
			m_pIEventService->ShowEventNotify(szDescribe,Level_Normal);

			GT_ASSERT(m_pGameServiceParameter);
			memcpy(m_pGameServiceParameter, pInfo, sizeof(CMD_CS_LoaderServerInfo));


			CXOREncrypt::CrevasseData(pInfo->GameUserDBInfo.szDataBasePipeName,m_pInitParamter->m_szGameUserDBPipeName,CountArray(m_pInitParamter->m_szGameUserDBPipeName));
			CXOREncrypt::CrevasseData(pInfo->GameUserDBInfo.szDataBaseUser,m_pInitParamter->m_szGameUserDBUser,CountArray(m_pInitParamter->m_szGameUserDBUser));
			CXOREncrypt::CrevasseData(pInfo->GameUserDBInfo.szDataBasePass,m_pInitParamter->m_szGameUserDBPass,CountArray(m_pInitParamter->m_szGameUserDBPass));
			m_pInitParamter->m_wGameUserDBPort = pInfo->GameUserDBInfo.wDataBasePort;
			struct in_addr in;
			in.S_un.S_addr	= pInfo->GameUserDBInfo.dwDataBaseAddr;
			strcpy(m_pInitParamter->m_szGameUserDBAddr,inet_ntoa(in));
			strcpy(m_pInitParamter->m_szGameUserDBName, szGameUserDB);

			CXOREncrypt::CrevasseData(pInfo->GameScoreDBInfo.szDataBasePipeName,m_pInitParamter->m_szServerInfoDBPipeName,CountArray(m_pInitParamter->m_szServerInfoDBPipeName));
			CXOREncrypt::CrevasseData(pInfo->GameScoreDBInfo.szDataBaseUser,m_pInitParamter->m_szServerInfoDBUser,CountArray(m_pInitParamter->m_szServerInfoDBUser));
			CXOREncrypt::CrevasseData(pInfo->GameScoreDBInfo.szDataBasePass,m_pInitParamter->m_szServerInfoDBPass,CountArray(m_pInitParamter->m_szServerInfoDBPass));
			m_pInitParamter->m_wServerInfoDBPort = pInfo->GameScoreDBInfo.wDataBasePort;
			in.S_un.S_addr	= pInfo->GameScoreDBInfo.dwDataBaseAddr;
			strcpy(m_pInitParamter->m_szServerInfoDBAddr,inet_ntoa(in));
			strcpy(m_pInitParamter->m_szServerInfoDBName, szGameUserDB);


			GT_ASSERT(m_pParentContainer!=NULL);
			m_pParentContainer->OnRequestInfoOk(0,0);


			return true;
		}
	case SUB_CS_GET_LOADERSERVERINFO_FAILD:
		{
			GT_ASSERT(m_pIEventService!=NULL);
			TCHAR szDescribe[128]=TEXT("");
			_snprintf(szDescribe,sizeof(szDescribe),TEXT("【服务ID %ld】启动服务失败"),(LONG)m_pInitParamter->m_wServerID);
			m_pIEventService->ShowEventNotify(szDescribe,Level_Exception);

			return true;
		}
	default:
		break;
	}
	return false;
}

//请求消息
HRESULT CControlWnd::OnAsynRequest(WPARAM wParam, LPARAM lParam)
{
	//效验变量
	GT_ASSERT(m_pAsynchronismEngine!=NULL);

	//获取参数
	WORD wRequestID=(WORD)wParam;
	IAsynchronismEngineSink * pIAsynchronismEngineSink=(IAsynchronismEngineSink *)lParam;

	//请求处理
	GT_ASSERT(pIAsynchronismEngineSink!=NULL);
	m_pAsynchronismEngine->OnAsynchronismRequest(wRequestID,pIAsynchronismEngineSink);

	return 0;
}

// ---------------------------------------------------------------------------
// Name:        suCallsHistoryLogger::suCallsHistoryLogger
// Description: Constructor
//
// Author:      Yaki Tebeka
// Date:        5/7/2003
// ---------------------------------------------------------------------------
suCallsHistoryLogger::suCallsHistoryLogger(apContextID contextId, apMonitoredFunctionId creationFunc, unsigned int maxLoggedFunctions, const wchar_t* loggerMessagesLabelFormat, bool threadSafeLogging)
    : _contextId(contextId),
      m_contextCreationFunc(creationFunc),
      _isLoggingEnabled(true),
      _threadSafeLogging(threadSafeLogging),
      _loggingCSEntered(false),
      _maxLoggedFunctions(maxLoggedFunctions),
      _isHTMLLogFileActive(false),
      _rawMemoryLogger(INITIALE_SIZE_OF_RAW_MEMORY, threadSafeLogging),
      _lastCalledFunctionId(apMonitoredFunctionsAmount),
      _isInOpenGLBeginEndBlock(false),
      _allocationFailureOccur(false),
      _transferableObjTypeToParameter(NULL)
{
    // Initialize the logger messages label:
    _loggerMessagesLabel.appendFormattedString(loggerMessagesLabelFormat, contextId._contextId);

    // Initialize the _transferableObjTypeToParameter vector:
    bool rc = initializeTransferableObjectTypeVec();
    GT_ASSERT(rc);

    // Register me to receive _rawMemoryLogger memory allocation failures notifications:
    _rawMemoryLogger.registerAllocationFailureObserver(this);

    // Initialize the log file creation time to the current time:
    _logCreationTime.setFromCurrentTime();
}

// ---------------------------------------------------------------------------
// Name:        osMessageBox::iconToOSStyle
// Description: Translated osMessageBoxIcon to OS message box style mask.
// Arguments:   icon - The input icon.
// Return Val:  unsigned int - The output OS style mask.
// Author:      AMD Developer Tools Team
// Date:        6/10/2004
// ---------------------------------------------------------------------------
unsigned int oaMessageBoxIconToOSStyle(osMessageBox::osMessageBoxIcon icon)
{
    // Translate from osDefaultOSIconType to Win32 message box styles:
    unsigned int retVal = 0;

    switch (icon)
    {
    case osMessageBox::OS_EXCLAMATION_POINT_ICON:
        retVal = MB_ICONEXCLAMATION;
        break;

    case osMessageBox::OS_DISPLAYED_INFO_ICON:
        retVal = MB_ICONINFORMATION;
        break;

    case osMessageBox::OS_QUESTION_MARK_ICON:
        retVal = MB_ICONQUESTION;
        break;

    case osMessageBox::OS_STOP_SIGN_ICON:
        retVal = MB_ICONSTOP;
        break;

    default:
        // Unknown icon type:
        GT_ASSERT(false);
    }

    return retVal;
}

// ---------------------------------------------------------------------------
// Name:        bool osFilePathByLastModifiedDateCompareFunctor::operator ()(const osFilePath& file1, const osFilePath& file2)
// Description: Compares files by the last modification date
// Arguments:
//              file1, file2 - the two filePaths to compare
//Return Value:
//              Returns true iff the last access date of file1 is more recent than that of file2
// Author:      AMD Developer Tools Team
// Date:        2007/12/24
// ---------------------------------------------------------------------------
bool osFilePathByLastModifiedDateCompareFunctor::operator()(const osFilePath& file1, const osFilePath& file2)
{
    // The struct that hold the files information
    osStatStructure file1Properties, file2Properties;

    // Get the filenames
    gtString file1Name = file1.asString();
    gtString file2Name = file2.asString();

    // Get the files status
    int rc1 = osWStat(file1Name, file1Properties);
    int rc2 = osWStat(file2Name, file2Properties);

    GT_ASSERT(rc1 == 0 && rc2 == 0);

    // Extract the last modified date from the properties struct
    // lastModifiedFile1Time and lastModifiedFile2Time hold the number of seconds that passed since
    // January 1, 1970 until the last modification moment.
    // Notice: Do not use access time, since on Vista, access time is hardly ever changed.
    time_t lastModifiedFile1Time = file1Properties.st_mtime;
    time_t lastModifiedFile2Time = file2Properties.st_mtime;

    // If the number of seconds since January 1st, 1970 to the last access moment is bigger,
    // then the last access date is newer
    return (lastModifiedFile1Time > lastModifiedFile2Time);
}

// ---------------------------------------------------------------------------
// Name:        osNULLSocket::read
// Description: Fails and generates an assertion failure.
// Author:      AMD Developer Tools Team
// Date:        25/8/2005
// ---------------------------------------------------------------------------
bool osNULLSocket::read(gtByte* pDataBuffer, gtSize_t dataSize)
{
    (void)(pDataBuffer); // unused
    (void)(dataSize); // unused
    GT_ASSERT(false);
    return false;
}

gpTraceSummaryTable::gpTraceSummaryTable(gpTraceDataContainer* pDataContainer, gpTraceView* pSessionView, eCallType callType)
    : acListCtrl(nullptr), m_callType(callType), m_pSessionDataContainer(pDataContainer), m_pTraceView(pSessionView), m_lastSelectedRowIndex(-1)
{
    QStringList columnCaptions;
    columnCaptions << GP_STR_SummaryTableColumnCall;
    columnCaptions << GP_STR_SummaryTableColumnMaxTime;
    columnCaptions << GP_STR_SummaryTableColumnMinTime;
    columnCaptions << GP_STR_SummaryTableColumnAvgTime;
    columnCaptions << GP_STR_SummaryTableColumnCumulativeTime;
    columnCaptions << GP_STR_SummaryTableColumnPercentageOfTotalTime;
    columnCaptions << GP_STR_SummaryTableColumnNumberOfCalls;
    initHeaders(columnCaptions, false);
    setShowGrid(true);

    m_logic.Init(m_callType, m_pSessionDataContainer, pSessionView);

    // fill Table widget
    FillTable();
    setSortingEnabled(true);
    setSelectionMode(QAbstractItemView::SingleSelection);
    setContextMenuPolicy(Qt::NoContextMenu);

    // Connect to the cell entered signal
    setMouseTracking(true);
    bool rc = connect(this, SIGNAL(cellEntered(int, int)), this, SLOT(OnCellEntered(int, int)));
    GT_ASSERT(rc);
}

HRESULT CaPerfDataWriter::writeSampleEvent(CaPerfEvent& event)
{
    caperf_section_evtcfg  evtCfg;
    const PerfEventDataList* eventDataList = event.getEventDataList();
    caperf_section_sample_id_t  sinfo;

    evtCfg.event_config   = event.getAttribute();
    evtCfg.start_idx      = m_sampleIdList.size();
    evtCfg.number_entries = eventDataList->size();

    // TODO: Set the name of the event
    memset(evtCfg.name, 0, sizeof(evtCfg.name));

    ssize_t rc = write(m_fd, (const void*)&evtCfg, sizeof(evtCfg));
    GT_ASSERT(rc != -1);

    // save the sample-id/cpu-id stuff in m_sampleIdList;
    OS_OUTPUT_FORMAT_DEBUG_LOG(OS_DEBUG_LOG_DEBUG, L"writeSampleEvent - eventDataList size(%d)", eventDataList->size());

    PerfEventDataList::const_iterator iter = eventDataList->begin();

    for (; iter != eventDataList->end(); iter++)
    {
        sinfo.sample_id = iter->m_sampleId;
        sinfo.cpuid = iter->m_cpu;
        sinfo.misc = 0;

        OS_OUTPUT_FORMAT_DEBUG_LOG(OS_DEBUG_LOG_EXTENSIVE, L"sinfo- smaple_id(0x%lx), cpuid(%d)", sinfo.sample_id, sinfo.cpuid);

        m_sampleIdList.push_back(sinfo);
    }

    return S_OK;
}

gtString SessionActions::menuPosition(int actionIndex, afActionPositionData& positionData)
{
    gtString retVal;

    positionData.m_actionSeparatorType = afActionPositionData::AF_SEPARATOR_NONE;

    // Get the command id:
    int commandId = actionIndexToCommandId(actionIndex);

    switch (commandId)
    {
        case ID_COPY:
        case ID_FIND_NEXT:
            retVal = AF_STR_EditMenuString;
            break;

        case ID_FIND:
        case ID_SELECT_ALL:
            positionData.m_actionSeparatorType = afActionPositionData::AF_SEPARATOR_BEFORE_COMMAND;
            retVal = AF_STR_EditMenuString;
            break;

        default:
            GT_ASSERT(false);
            break;
    };

    return retVal;
}

// ---------------------------------------------------------------------------
// Name:        osSharedMemorySocket::write
// Description: Writes a block of data into the shared memory socket.
// Arguments:   pDataBuffer - A pointer to a buffer that contains the
//                            data to be written.
//              dataSize - The data size.
// Return Val:  bool - Success / failure.
// Author:      AMD Developer Tools Team
// Date:        17/8/2005
// Implementation notes:
//   The data buffer is cyclic, therefore, we write the data in 2 chunks:
//   - All data that fits until we reach the end of the buffer.
//   - All the remaining data (if any) will be written from the buffer begin point.
// ---------------------------------------------------------------------------
bool osSharedMemorySocket::write(const gtByte* pDataBuffer, unsigned long dataSize)
{
    bool retVal = false;

    // Verify that the socket is open:
    if (isOpen())
    {
        // Wait for enough space to be available in my outgoing data:
        bool hasEnoughSpaceToWriteData = waitForAvailableSpaceToWriteData(dataSize, _writeOperationTimeOut);

        // If after waiting the time interval, we still don't have enough space available:
        if (!hasEnoughSpaceToWriteData)
        {
            // Do not write the data and trigger an assertion:
            GT_ASSERT(0);
        }
        else
        {
            // Lock / wait for my outgoing buffer resources:
            lockBufferResources(_pMyOutgoingBuffLocked);

            // Update the outgoing buffer free space:
            *_pMyOutgoingDataBuffFreeSpace -= dataSize;

            // Calculate the first and second chunk sizes (see "implementation notes" above):
            int firstChunkSize = min(int(dataSize), (_communicationBufferSize - *_pMyWritePos));
            int secondChunkSize = dataSize - firstChunkSize;

            // Copy the first data chunk:
            void* pWriteLocation = _pMyOutgoingDataBuff + *_pMyWritePos;
            memcpy(pWriteLocation, pDataBuffer, firstChunkSize);

            // If we need a second chunk:
            if (secondChunkSize > 0)
            {
                // Copy the second data chunk (from the beginning of our outgoing buffer):
                memcpy(_pMyOutgoingDataBuff, (pDataBuffer + firstChunkSize), secondChunkSize);
                *_pMyWritePos = secondChunkSize;
            }
            else
            {
                *_pMyWritePos += dataSize;
            }

            // If my next write position passed the end of the buffer:
            if (_communicationBufferSize <= *_pMyWritePos)
            {
                *_pMyWritePos = 0;
            }

            // Release my outgoing buffer resources:
            unlockBufferResources(_pMyOutgoingBuffLocked);

            retVal = true;
        }
    }

    return retVal;
}

//设置事件
bool CCenterService::SetEventService(IUnknownEx * pIEventService)
{
	//获取接口
	GT_ASSERT(pIEventService!=NULL);
	m_pIEventService=(IEventService *)pIEventService->QueryInterface(IID_IEventService,VER_IEventService);
	GT_ASSERT(m_pIEventService!=NULL);

	//设置接口
	m_DataBaseSink.SetEventService(pIEventService);
	m_AttemperSink.SetEventService(pIEventService);
	if (m_ServiceEngine.IsValid()) 
	{
		m_ServiceEngine->SetEventService(pIEventService);
	}

	return (m_pIEventService!=NULL);
}