/*
   AngelCode Scripting Library
   Copyright (c) 2003-2016 Andreas Jonsson

   This software is provided 'as-is', without any express or implied 
   warranty. In no event will the authors be held liable for any 
   damages arising from the use of this software.

   Permission is granted to anyone to use this software for any 
   purpose, including commercial applications, and to alter it and 
   redistribute it freely, subject to the following restrictions:

   1. The origin of this software must not be misrepresented;  you 
      must not claim that you wrote the original software. If you use
      this software in a product, an acknowledgment in the product 
      documentation would be appreciated but is not required.

   2. Altered source versions must be plainly marked as such, and 
      must not be misrepresented as being the original software.

   3. This notice may not be removed or altered from any source 
      distribution.

   The original version of this library can be located at:
   http://www.angelcode.com/angelscript/

   Andreas Jonsson
   andreas@angelcode.com
*/


//
// as_debug.h
//

#ifndef AS_DEBUG_H
#define AS_DEBUG_H

#include "as_config.h"

#if defined(AS_DEBUG)

#ifndef AS_WII
// The Wii SDK doesn't have these, we'll survive without AS_DEBUG

#ifndef _WIN32_WCE
// Neither does WinCE

#ifndef AS_PSVITA
// Possible on PSVita, but requires SDK access

#if !defined(_MSC_VER) && (defined(__GNUC__) || defined(AS_MARMALADE))

#ifdef __ghs__ 
// WIIU defines __GNUC__ but types are not defined here in 'conventional' way 
#include <types.h>
typedef signed char int8_t; 
typedef unsigned char uint8_t; 
typedef signed short int16_t; 
typedef unsigned short uint16_t; 
typedef signed int int32_t; 
typedef unsigned int uint32_t; 
typedef signed long long int64_t; 
typedef unsigned long long uint64_t; 
typedef float float32_t; 
typedef double float64_t; 
#else
// Define mkdir for GNUC
#include <sys/stat.h>
#include <sys/types.h>
#define _mkdir(dirname) mkdir(dirname, S_IRWXU)
#endif
#else
#include <direct.h>
#endif

#endif // AS_PSVITA
#endif // _WIN32_WCE
#endif // AS_WII

#endif // !defined(AS_DEBUG)



#if defined(_MSC_VER) && defined(AS_PROFILE)
// Currently only do profiling with MSVC++

#include <mmsystem.h>
#include <direct.h>
#include "as_string.h"
#include "as_map.h"
#include "as_string_util.h"

BEGIN_AS_NAMESPACE

struct TimeCount
{
	double time; 
	int    count; 
	double max; 
	double min; 
}; 

class CProfiler
{
public:
	CProfiler()
	{
		// We need to know how often the clock is updated
		__int64 tps; 
		if( !QueryPerformanceFrequency((LARGE_INTEGER *)&tps) )
			usePerformance = false; 
		else
		{
			usePerformance = true; 
			ticksPerSecond = double(tps); 
		}

		timeOffset = GetTime(); 
	}

	~CProfiler()
	{
		WriteSummary(); 
	}

	double GetTime()
	{
		if( usePerformance )
		{
			__int64 ticks; 
			QueryPerformanceCounter((LARGE_INTEGER *)&ticks); 

			return double(ticks)/ticksPerSecond - timeOffset; 
		}
		
		return double(timeGetTime())/1000.0 - timeOffset; 
	}

	double Begin(const char *name)
	{
		double time = GetTime(); 

		// Add the scope to the key
		if( key.GetLength() )
			key += "|"; 
		key += name; 

		// Compensate for the time spent writing to the file
		timeOffset += GetTime() - time; 

		return time; 
	}

	void End(const char * /*name*/, double beginTime)
	{
		double time = GetTime(); 

		double elapsed = time - beginTime; 

		// Update the profile info for this scope
		asSMapNode<asCString, TimeCount> *cursor; 
		if( map.MoveTo(&cursor, key) )
		{
			cursor->value.time += elapsed; 
			cursor->value.count++; 
			if( cursor->value.max < elapsed ) 
				cursor->value.max = elapsed; 
			if( cursor->value.min > elapsed ) 
				cursor->value.min = elapsed; 
		}
		else
		{
			TimeCount tc = {elapsed, 1, elapsed, elapsed}; 
			map.Insert(key, tc); 
		}

		// Remove the inner most scope from the key
		int n = key.FindLast("|"); 
		if( n > 0 )
			key.SetLength(n); 
		else
			key.SetLength(0); 

		// Compensate for the time spent writing to the file
		timeOffset += GetTime() - time; 
	}
	
protected:
	void WriteSummary()
	{
		// Write the analyzed info into a file for inspection
		_mkdir("AS_DEBUG"); 
		FILE *fp; 
		#if _MSC_VER >= 1500 && !defined(AS_MARMALADE)
			fopen_s(&fp, "AS_DEBUG/profiling_summary.txt", "wt"); 
		#else
			fp = fopen("AS_DEBUG/profiling_summary.txt", "wt"); 
		#endif
		if( fp == 0 )
			return; 

		fprintf(fp, "%-60s %10s %15s %15s %15s %15s\n\n", "Scope", "Count", "Tot time", "Avg time", "Max time", "Min time"); 

		asSMapNode<asCString, TimeCount> *cursor; 
		map.MoveLast(&cursor); 
		while( cursor )
		{
			asCString key = cursor->key; 
			int count; 
			int n = key.FindLast("|", &count); 
			if( count )
			{
				key = asCString("                                               ", count) + key.SubString(n+1); 
			}

			fprintf(fp, "%-60s %10d %15.6f %15.6f %15.6f %15.6f\n", key.AddressOf(), cursor->value.count, cursor->value.time, cursor->value.time / cursor->value.count, cursor->value.max, cursor->value.min); 

			map.MovePrev(&cursor, cursor); 
		}

		fclose(fp); 
	}

	double  timeOffset; 
	double  ticksPerSecond; 
	bool    usePerformance; 

	asCString                    key; 
	asCMap<asCString, TimeCount> map; 
}; 

extern CProfiler g_profiler; 

class CProfilerScope
{
public:
	CProfilerScope(const char *name)
	{
		this->name = name; 
		beginTime = g_profiler.Begin(name); 
	}

	~CProfilerScope()
	{
		g_profiler.End(name, beginTime); 
	}

protected:
	const char *name; 
	double      beginTime; 
}; 

#define TimeIt(x) CProfilerScope profilescope(x)

END_AS_NAMESPACE

#else // !(_MSC_VER && AS_PROFILE)

// Define it so nothing is done
#define TimeIt(x) 

#endif // !(_MSC_VER && AS_PROFILE)




#endif // defined(AS_DEBUG_H)


