int CIpAddress::LookupHost( const t_string &x_sServer, unsigned int x_uPort, unsigned int x_uType )
{
#if defined( HTM_NOSOCKET2 )
	return 0;
#else
    // Lose old info
    Destroy();

    // Ensure we have a valid pointer
    if ( !x_sServer.length() )
        return 0;

	// First try to interpret as dot address
	unsigned long uAddr = inet_addr( x_sServer.c_str() );
	if ( INADDR_NONE == uAddr )
    {
        LPHOSTENT pHe = gethostbyname( x_sServer.c_str() );

        if ( !pHe )
            return 0;

        LPIN_ADDR pia = (LPIN_ADDR)*pHe->h_addr_list;
        if ( !pia )
            return 0;

        // Grab the address
        uAddr = *(DWORD*)&pia->S_un.S_addr;

    } // end if

    SetRawAddress( ntohl( uAddr ), x_uPort, x_uType );

    return 1;
#endif
}

variant luaW_tofaivariant(lua_State* L, int i) {
	switch(lua_type(L, i)) {
		case LUA_TBOOLEAN:
			return variant(lua_tointeger(L, i));
		case LUA_TNUMBER:
			return variant(lua_tonumber(L, i), variant::DECIMAL_VARIANT);
		case LUA_TSTRING:
			return variant(lua_tostring(L, i));
		case LUA_TTABLE:
			return variant(new lua_callable(L, i));
		case LUA_TUSERDATA:
			static t_string tstr;
			static vconfig vcfg = vconfig::unconstructed_vconfig();
			static map_location loc;
			if(luaW_totstring(L, i, tstr)) {
				return variant(tstr.str());
			} else if(luaW_tovconfig(L, i, vcfg)) {
				return variant(new config_callable(vcfg.get_parsed_config()));
			} else if(unit* u = luaW_tounit(L, i)) {
				return variant(new unit_callable(*u));
			} else if(luaW_tolocation(L, i, loc)) {
				return variant(new location_callable(loc));
			}
			break;
	}
	return variant();
}

t_string interpolate_variables_into_tstring(const t_string &tstr, const variable_set& variables)
{
	if(!tstr.str().empty()) {
		std::string interp = utils::interpolate_variables_into_string(tstr.str(), variables);
		if(tstr.str() != interp) {
			return t_string(interp);
		}
	}
	return tstr;
}

/*
 * From the IRC log of 23.07.2010
 * 07:52 <silene> Upth: what did it break?
 * 07:53 <Upth> silene: since that revision, the windows executable crashes
 * immediately before loading the main menu
 * 07:54 <silene> what kind of crash?
 * 07:54 <Upth> assertion failed in the std::string library
 * 07:54 <Upth> then "fatal error"
 * 07:54 <Upth> and abnormal termination
 * 07:54 <silene> which assertion?
 * 07:55 <Upth> Expression: ("_Myptr + _Off <= (((_Mystring
 * *)this->_Mycont)->_Myptr() + ((_Mystring *)this->_Mycont)->_Mysize) &&
 * _Myptr + _Off >= ((_Mystring *)this->_Mycont)->_Myptr()", 0)
 * 07:56 <shadowmaster> ugly.
 * 07:57 <Upth> in the iterator += overload, called from the iterator +
 * overload, called from std::basic_string::end(), called from line 409 of
 * parser.cpp in write_key_val
 * 07:58 <Upth> err std::basic_string::end() is called from
 * t_string::walker::end(), which is called on line 409 of parser.cpp
 * 07:58 <silene> that doesn't make sense; as far as i can tell it's a compiler
 * bug
 * 07:58 <silene> which compiler is that so that the code is made conditional
 * on it?
 * 07:58 <Upth> MSVC9
 */
t_string_base::walker::walker(const t_string& string) :
	string_(string.get().value_),
	begin_(0),
	end_(string_.size()),
	textdomain_(),
	translatable_(false)
{
	if(string.get().translatable_) {
		update();
	}
}

void generate_pot(std::set<std::string>& msgids, const t_string& tstr, const std::string& default_textdomain)
{
	if (tstr.str().empty()) {
		return;
	}
	std::vector<t_string_base::trans_str> trans = tstr.valuex();
	if (!trans.empty()) {
		if (trans[0].td.empty() || trans[0].td == default_textdomain) {
			msgids.insert(trans[0].str);
		}
	}
	return;
}

// +++ Make IPv6 safe
int CIpAddress::SetDotAddress( const t_string &x_sDotAddress, unsigned int x_uPort, unsigned int x_uType )
{
    if ( !x_sDotAddress.length() )
        return 0;

    // Convert the dot address
    u_long ip = ntohl( inet_addr( x_sDotAddress.c_str() ) );
    if ( INADDR_NONE == ip )
        return 0;

    SetRawAddress( ip, x_uPort, x_uType );

    return 1;
}

CIpAddress::t_string CIpAddress::GetDomainName( const t_string &x_sServer )
{
	CIpAddress::t_string sRet;

	// Load netapi32.dll
	HMODULE hLib = LoadLibrary( tcT( "netapi32.dll" ) );
	if ( !hLib )
		return sRet;

	// Get function pointers
	pfn_NetApiBufferFree pNetApiBufferFree = (pfn_NetApiBufferFree)GetProcAddress( hLib, tcT( "NetApiBufferFree" ) );
	pfn_NetWkstaGetInfo pNetWkstaGetInfo = (pfn_NetWkstaGetInfo)GetProcAddress( hLib, tcT( "NetWkstaGetInfo" ) );

	// Attempt to read the domain name
	WKSTA_INFO_100 *pwi100 = 0;
	if ( pNetWkstaGetInfo
		 && !pNetWkstaGetInfo( x_sServer.length() ? (LPWSTR)tcStr2Wc( x_sServer ).c_str() : 0, 100, (LPBYTE*)&pwi100 ) )
		if ( pwi100 && pwi100->wki100_langroup )
			sRet = tcWc2Str( pwi100->wki100_langroup );

	// Free buffer
	if ( pNetApiBufferFree && pwi100 )
		pNetApiBufferFree( pwi100 );

	// Free library
	FreeLibrary( hLib );

	// Send the domain name along
	return sRet;
}

int CIpAddress::LookupUri( const t_string &x_sUrl, unsigned int x_uPort, unsigned int x_uType )
{
    // Lose old info
    Destroy();

    // Ensure we have a valid pointer
    if ( !x_sUrl.length() )
        return 0;

    // Crack the url
    t_pb8 pbUri = parser::DecodeUri< t_pb8 >( x_sUrl );
    if ( !pbUri.size() )
        return 0;

    // Did we get a host name?
    if ( !pbUri[ "host" ].length() )
        return 0;

    // Get the port
    if ( !x_uPort )
        x_uPort = pbUri[ "port" ].ToLong();

    // Save the type
    m_uType = x_uType;

    return LookupHost( pbUri[ "host" ].str(), x_uPort );
}

bool DirUtil::CreateDirectory( const t_string &dirPath )
{
    if (!CreateParentDirectory(dirPath))
    {
        return false;
    }
    return ::CreateDirectory(dirPath.c_str(), NULL) == TRUE;
}

bool DirUtil::DeleteDirectory( const t_string &path )
{
#if 0
    SHFILEOPSTRUCT FileOp;
    ZeroMemory((void*)&FileOp, sizeof(SHFILEOPSTRUCT));

    t_string strFromPath = MakePathRegular(path);
    // this string must be double-null terminated
    strFromPath.append(1, _T('\0'));

    FileOp.fFlags = FOF_NOCONFIRMATION | FOF_NOCONFIRMMKDIR | FOF_NOERRORUI | FOF_SILENT;
    FileOp.hNameMappings = NULL;
    FileOp.hwnd = NULL;
    FileOp.lpszProgressTitle = NULL;
    FileOp.pFrom = strFromPath.c_str();
    FileOp.pTo = NULL;
    FileOp.wFunc = FO_DELETE;

    return SHFileOperation(&FileOp) == 0;
#endif
    bool ret = true;
    std::vector<t_string> fileList;
    std::vector<t_string> dirList;
    if (EnumFiles(path, fileList))
    {
        for (size_t i = 0; i < fileList.size(); i++)
        {
            if (!DeleteFileIfExist(fileList.at(i)))
            {
                ret = false;
                break;
            }
        }
    }
    if (!ret)
    {
        return false;
    }

    if (EnumDirs(path, dirList))
    {
        for (size_t i = 0; i < dirList.size(); i++)
        {
            if (!DeleteDirectory(dirList.at(i)))
            {
                ret = false;
                break;
            }
        }
    }
    if (!ret)
    {
        return false;
    }
    return ::RemoveDirectory(path.c_str()) ? true : false;
}

bool DirUtil::DeleteFileIfExist( const t_string &filePath )
{
    if (IsFileExist(filePath))
    {
        if (!::DeleteFile(filePath.c_str()))
        {
            _tchmod(filePath.c_str(), 0777);
            return ::DeleteFile(filePath.c_str()) ? true : false;
        }
        else
        {
            return true;
        }
    }
    else
    {
        return false;
    }
}

void team::change_team(const std::string& name, const t_string& user_name)
{
	info_.team_name = name;

	if(!user_name.empty()) {
		info_.user_team_name = user_name;
	} else {
		info_.user_team_name = name;
	}

	clear_caches();
}

void write_key_val(std::ostream &out, const std::string &key, const t_string &value, unsigned int level, std::string& textdomain)
{
	bool first = true;
	if (value.empty()) {
		out << std::string(level, '\t') << key << AttributeEquals
			<< AttributePrefix << AttributePostfix
			<< AttributeEndPostfix;;
		return;
	}

	for(t_string::walker w(value); !w.eos(); w.next()) {
		std::string part(w.begin(), w.end());

		if(w.translatable()) {
			if(w.textdomain() != textdomain) {
				out << TextdomainPrefix
					<< w.textdomain()
					<< TextdomainPostfix;
				textdomain = w.textdomain();
			}

			if(first) {
				out << std::string(level, '\t')
					<< key
					<< AttributeEquals;
			}

			out << TranslatableAttributePrefix
				<< escaped_string(part)
				<< AttributePostfix;

		} else {
			if(first) {
				out << std::string(level, '\t')
					<< key
					<< AttributeEquals;
			}

			out << AttributePrefix
				<< escaped_string(part)
				<< AttributePostfix;
		}

		if(w.last()) {
			out << AttributeEndPostfix;
		} else {
			out << AttributeContPostfix;
			out << std::string(level+1, '\t');
		}

		first = false;
	}
}

    DWORD Base::Write(const t_string & write_buffer, HANDLE pipe_handle, CRITICAL_SECTION & write_critical_section)
    {
        if (eState_ != STATE::started)
        {
            return ERROR_NOT_FOUND;
        }    

        EnterCriticalSection(&write_critical_section);

            DWORD cbWritten;

            BOOL bSuccess = WriteFile ( 
                                            pipe_handle,                                            // pipe handle 
                                            write_buffer.c_str(),                                   // message 
                                            write_buffer.length() * 
                                            sizeof(t_string::traits_type::char_type),               // message length 
                                            &cbWritten,                                             // bytes written 
                                            NULL                                                    // not overlapped 
                                        );

        LeaveCriticalSection(&write_critical_section);

        return bSuccess ? ERROR_SUCCESS : GetLastError();
    }

    DWORD Client::Write(t_string write_buffer)
    {
        if (eState_ != STATE::started)
        {
            return ERROR_NOT_FOUND;
        }

        DWORD cbWritten;

        EnterCriticalSection(&csPipe_Write_);

            BOOL bSuccess = WriteFile ( 
                                            hPipe_,                                                 // pipe handle 
                                            write_buffer.c_str(),                                   // message 
                                            write_buffer.length() * 
                                            sizeof(t_string::traits_type::char_type),               // message length 
                                            &cbWritten,                                             // bytes written 
                                            NULL                                                    // not overlapped 
                                        );

        LeaveCriticalSection(&csPipe_Write_);

        return bSuccess ? ERROR_SUCCESS : GetLastError();
    }

int CIpSocket::Connect( const t_string &x_sAddress, unsigned int x_uPort )
{
	if ( !x_sAddress.length() )
        return 0;

	// Punt if not initialized
	if ( !IsInitialized() )
		return 0;

	CIpAddress addr;

    // Were we passed a URL?
    if ( !x_uPort && addr.LookupUri( x_sAddress ) )
		return Connect( addr );

	// Lookup the host address
    if ( addr.LookupHost( x_sAddress, x_uPort ) )
		return Connect( addr );

	return 0;
}

/*WIKI
 * @begin{tag}{name="tip"}{min="0"}{max="-1"}
 * @begin{table}{config}
 *     source & t_string & & Author
 *     text & t_string & & Text of the tip.
 * @end{table}
 * @end{tag}{name="tip"}
 * @end{parent}{name="gui/"}
 */
const std::string& tgui_definition::read(const config& cfg)
{
	id = cfg["id"].str();
	description = cfg["description"];

	VALIDATE(!id.empty(), missing_mandatory_wml_key("gui", "id"));
	VALIDATE(!description.empty(),
			 missing_mandatory_wml_key("gui", "description"));

	DBG_GUI_P << "Parsing gui " << id << '\n';

	/***** Control definitions *****/

	for(auto & widget_type : registred_widget_type())
	{
		widget_type.second(*this, widget_type.first, cfg, nullptr);
	}

	/***** Window types *****/
	for(const auto & w : cfg.child_range("window"))
	{
		std::pair<std::string, twindow_builder> child;
		child.first = child.second.read(w);
		window_types.insert(child);
	}

	if(id == "default") {
		// The default gui needs to define all window types since we're the
		// fallback in case another gui doesn't define the window type.
		for(std::vector<std::string>::const_iterator itor
			= registered_window_types().begin();
			itor != registered_window_types().end();
			++itor) {

			const std::string error_msg(
					"Window not defined in WML: '" + *itor
					+ "'. Perhaps a mismatch between data and source versions."
					  " Try --data-dir <trunk-dir>");
			VALIDATE(window_types.find(*itor) != window_types.end(), error_msg);
		}
	}

	/***** settings *****/

	/**
	 * @todo Regarding sounds:
	 * Need to evaluate but probably we want the widget definition be able to:
	 * - Override the default (and clear it). This will allow toggle buttons in
	 * a
	 *   listbox to sound like a toggle panel.
	 * - Override the default and above per instance of the widget, some buttons
	 *   can give a different sound.
	 */
	const config& settings = cfg.child("settings");

	popup_show_delay_ = settings["popup_show_delay"];
	popup_show_time_ = settings["popup_show_time"];
	help_show_time_ = settings["help_show_time"];
	double_click_time_ = settings["double_click_time"];

	repeat_button_repeat_time_ = settings["repeat_button_repeat_time"];

	VALIDATE(double_click_time_,
			 missing_mandatory_wml_key("settings", "double_click_time"));

	sound_button_click_ = settings["sound_button_click"].str();
	sound_toggle_button_click_ = settings["sound_toggle_button_click"].str();
	sound_toggle_panel_click_ = settings["sound_toggle_panel_click"].str();
	sound_slider_adjust_ = settings["sound_slider_adjust"].str();

	has_helptip_message_ = settings["has_helptip_message"];

	VALIDATE(!has_helptip_message_.empty(),
			 missing_mandatory_wml_key("[settings]", "has_helptip_message"));

	tips_ = tips::load(cfg);

	return id;
}

	variant operator()(const t_string& s) const {return variant(s.str());}

bool DirUtil::EnumFilesOrDir( const t_string &path, std::vector<t_string> &fileList, int enumType)
{
    if (path.empty())
    {
        return false;
    }

    t_string strDirPath = MakePathRegular(path);
    if (strDirPath.find_last_of(DEFAULT_PATH_SPLITER) != strDirPath.length() - 1)
    {
        strDirPath.push_back(DEFAULT_PATH_SPLITER);
    }

    t_string filter = strDirPath;
    filter.append(_T("*"));

    WIN32_FIND_DATA fd;
    HANDLE  hFind = FindFirstFile( filter.c_str(), &fd );
    if ( hFind == INVALID_HANDLE_VALUE ){
        return false;
    }

    do
    {
        if (ENUM_FILE & enumType)
        {
            if (!(fd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
            {
                if (ENUM_ONLY_FILE_NAME & enumType)
                {
                    fileList.push_back(fd.cFileName);
                }
                else
                {
                    t_string fp = strDirPath;
                    fp.append(fd.cFileName);
                    fileList.push_back(fp);
                }
            }
        }

        if (ENUM_DIR & enumType)
        {
            if ( _tcscmp(fd.cFileName, _T(".")) != 0
                && _tcscmp(fd.cFileName, _T("..")) != 0
                && (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
            {
                if (ENUM_ONLY_FILE_NAME & enumType)
                {
                    fileList.push_back(fd.cFileName);
                }
                else
                {
                    t_string fp = strDirPath;
                    fp.append(fd.cFileName);
                    fileList.push_back(fp);
                }
            }
        }

    } while ( FindNextFile( hFind, &fd ) != 0 );

    FindClose( hFind );

    return true;
}

inline t_string operator+(const std::string& a, const t_string& b) { return t_string(a + b.str()); }