void ServiceMain(DWORD argc, LPCWSTR* argv)
{
  // ...
  
	UpdateServiceStatus(SERVICE_START_PENDING, NO_ERROR, 0, 3000);

	std::thread work_thread(WorkThread);

	UpdateServiceStatus(SERVICE_RUNNING, NO_ERROR, 0, 0);
	 
	work_thread.join();
	
	UpdateServiceStatus(SERVICE_STOPPED, NO_ERROR, 0, 0);
}

BOOL UpdateServiceStatus(
  DWORD current_state, 
  DWORD exit_code, 
  DWORD specific_exit_code, 
  DWORD wait_hint
  )
{
	static DWORD check_point = 1;
	SERVICE_STATUS service_status = { 0 };
	service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
	service_status.dwCurrentState = current_state;
	service_status.dwControlsAccepted = (current_state == SERVICE_RUNNING) ? (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN) : 0;
	service_status.dwWin32ExitCode = (specific_exit_code == 0) ? exit_code : ERROR_SERVICE_SPECIFIC_ERROR;
	service_status.dwServiceSpecificExitCode = specific_exit_code;
	service_status.dwWaitHint = wait_hint;
	service_status.dwCheckPoint = ((current_state == SERVICE_RUNNING) || (current_state == SERVICE_STOPPED)) ? 0 : check_point++;

	return SetServiceStatus(service_state_handle, &service_status);
}

DWORD WINAPI ServiceHandlerEx(
  DWORD dwControl, 
  DWORD dwEventType, 
  LPVOID lpEventData, 
  LPVOID lpContext
)
{
	switch ( dwControl )
	{
	case SERVICE_CONTROL_SHUTDOWN:
	case SERVICE_CONTROL_STOP:
		UpdateServiceStatus(SERVICE_STOP_PENDING, NO_ERROR, 0, 0);
		is_running = FALSE;
		return NO_ERROR;
	default:
		break;
	}
	return NO_ERROR;
}

void WorkThread()
{
	const std::wstring process_path = L"C:\\windows\\system32\\notepad.exe";

	BOOL executed = FALSE;

	while ( is_running )
	{
		if ( !executed )
		{
			executed = RunAsExplorer(process_path.c_str());
		}

		Sleep(2000);
	}
}

#include <windows.h>
#include <winsvc.h>
#include <Tlhelp32.h>
#include <process.h>
#include <psapi.h>
#include <sddl.h>

#include <iomanip>
#include <iostream>
#include <map>
#include <mutex>
#include <thread>

#include "spdlog/sinks/basic_file_sink.h"
#include "spdlog/spdlog.h"

static WCHAR kServiceName[] = L"StudioYS Launcher Service";

SERVICE_STATUS_HANDLE service_state_handle;
BOOL is_running = FALSE;

std::mutex mutex_lock;

SC_HANDLE OpenSCM(DWORD desired_access)
{
	SC_HANDLE service_manager = OpenSCManagerW(NULL, NULL, desired_access);

	if ( service_manager == NULL )
	{
		spdlog::error("OpenSCManager Failed: 0x{:08x}", GetLastError());
	}

	return service_manager;
}

BOOL GetExplorerToken(HANDLE& hToken)
{
	spdlog::info("[GetExplorerToken] Start");

	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

	if ( hSnapshot == INVALID_HANDLE_VALUE )
	{
		spdlog::error("[GetExplorerToken] CreateToolhelp32Snapshot Failed : 0x{:08x}", GetLastError());
		return FALSE;
	}

	DWORD explorerPID = 0;
	PROCESSENTRY32 pe;
	pe.dwSize = sizeof(PROCESSENTRY32);

	// Find explorer.exe process
	if ( Process32First(hSnapshot, &pe) )
	{
		do
		{
			if ( _wcsicmp(pe.szExeFile, L"explorer.exe") == 0 )
			{
				explorerPID = pe.th32ProcessID;
				spdlog::debug("[GetExplorerToken] Found Explorer PID : {}", explorerPID);
				break;
			}
		} while ( Process32Next(hSnapshot, &pe) );
	}

	CloseHandle(hSnapshot);

	if ( explorerPID == 0 )
	{
		spdlog::error("[GetExplorerToken] Explorer process not found.");
		return FALSE;
	}

	// Open process and get token
	HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, explorerPID);
	if ( hProcess == NULL )
	{
		spdlog::error("[GetExplorerToken] OpenProcess failed for Explorer PID: 0x{:08x}", GetLastError());
		return FALSE;
	}

	if ( !OpenProcessToken(hProcess, TOKEN_DUPLICATE | TOKEN_ASSIGN_PRIMARY | TOKEN_QUERY, &hToken) )
	{
		CloseHandle(hProcess);
		spdlog::error("[GetExplorerToken] OpenProcessToken failed: 0x{:08x}", GetLastError());
		return FALSE;
	}

	CloseHandle(hProcess);
	spdlog::info("[GetExplorerToken] Successfully retrieved explorer token.");
	return TRUE;
}

BOOL RunAsExplorer(LPCWSTR lpApplicationName)
{
	HANDLE hToken;
	if ( !GetExplorerToken(hToken) )
	{
		spdlog::error("[RunAsExplorer] Failed to get explorer token");
		return FALSE;
	}

	HANDLE hNewToken;
	if ( !DuplicateTokenEx(hToken, MAXIMUM_ALLOWED, NULL, SecurityImpersonation, TokenPrimary, &hNewToken) )
	{
		CloseHandle(hToken);
		spdlog::error("[RunAsExplorer] Failed to duplicate token: 0x{:08x}", GetLastError());
		return FALSE;
	}

	STARTUPINFOW si = { sizeof(STARTUPINFOW) };
	PROCESS_INFORMATION pi = { 0 };

	BOOL result = CreateProcessAsUserW(hNewToken, lpApplicationName, NULL, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);

	if ( result )
	{
		spdlog::info("[RunAsExplorer] Successfully created process.");
		CloseHandle(pi.hProcess);
		CloseHandle(pi.hThread);
	}
	else
	{
		spdlog::error("[RunAsExplorer] Failed to create process: 0x{:08x}", GetLastError());
	}

	CloseHandle(hToken);
	CloseHandle(hNewToken);
	return result;
}

void WorkThread()
{
	spdlog::info("[WorkThread] Start");

	const std::wstring process_path = L"C:\\windows\\system32\\notepad.exe";

	BOOL executed = FALSE;

	while ( is_running )
	{
		if ( !executed )
		{
			if ( executed = RunAsExplorer(process_path.c_str()) )
			{
				spdlog::info("[WorkThread] run process");
			}
			else
			{
				spdlog::error("[WorkThread] Failed to run process");
			}
		}

		Sleep(2000);
	}

	spdlog::info("[WorkThread] Finish");
}

BOOL UpdateServiceStatus(DWORD current_state, DWORD exit_code, DWORD specific_exit_code, DWORD wait_hint)
{
	static DWORD check_point = 1;
	SERVICE_STATUS service_status = { 0 };
	service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
	service_status.dwCurrentState = current_state;
	service_status.dwControlsAccepted = (current_state == SERVICE_RUNNING) ? (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN) : 0;
	service_status.dwWin32ExitCode = (specific_exit_code == 0) ? exit_code : ERROR_SERVICE_SPECIFIC_ERROR;
	service_status.dwServiceSpecificExitCode = specific_exit_code;
	service_status.dwWaitHint = wait_hint;
	service_status.dwCheckPoint = ((current_state == SERVICE_RUNNING) || (current_state == SERVICE_STOPPED)) ? 0 : check_point++;

	return SetServiceStatus(service_state_handle, &service_status);
}

DWORD WINAPI ServiceHandlerEx(DWORD dwControl, DWORD dwEventType, LPVOID lpEventData, LPVOID lpContext)
{
	switch ( dwControl )
	{
	case SERVICE_CONTROL_SHUTDOWN:
	case SERVICE_CONTROL_STOP:
		spdlog::info("SERVICE_CONTROL_STOP received");
		UpdateServiceStatus(SERVICE_STOP_PENDING, NO_ERROR, 0, 0);
		is_running = FALSE;
		return NO_ERROR;
	default:
		break;
	}
	return NO_ERROR;
}

void ServiceMain(DWORD argc, LPCWSTR* argv)
{
	spdlog::info("[ServiceMain] Start");

	service_state_handle = RegisterServiceCtrlHandlerEx(kServiceName, ServiceHandlerEx, NULL);
	if ( service_state_handle == NULL )
	{
		spdlog::error("[ServiceMain] RegisterServiceCtrlHandlerEx failed: 0x{:08x}", GetLastError());
		return;
	}

	UpdateServiceStatus(SERVICE_START_PENDING, NO_ERROR, 0, 3000);

	is_running = TRUE;
	std::thread work_thread(WorkThread);

	UpdateServiceStatus(SERVICE_RUNNING, NO_ERROR, 0, 0);
	 
	work_thread.join();
	UpdateServiceStatus(SERVICE_STOPPED, NO_ERROR, 0, 0);
}

void InstallMyService()
{
	SC_HANDLE service_manager = OpenSCM(SC_MANAGER_CREATE_SERVICE);
	if ( service_manager == NULL ) return;

	WCHAR file_path[MAX_PATH] = { 0 };
	GetModuleFileNameW(NULL, file_path, _countof(file_path));

	SC_HANDLE service_handle = CreateServiceW(
		service_manager, kServiceName, kServiceName, SERVICE_ALL_ACCESS,
		SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL,
		file_path, NULL, NULL, NULL, NULL, NULL);

	if ( service_handle == NULL )
	{
		spdlog::error("[InstallMyService] CreateService Failed: 0x{:08x}", GetLastError());
		CloseServiceHandle(service_manager);
		return;
	}

	WCHAR description[] = L"StudioYS Launcher Service Description";
	SERVICE_DESCRIPTION sd = { description };
	ChangeServiceConfig2W(service_handle, SERVICE_CONFIG_DESCRIPTION, &sd);

	CloseServiceHandle(service_handle);
	CloseServiceHandle(service_manager);

	spdlog::info("[InstallMyService] Service installed successfully.");
}

void UninstallMyService()
{
	SC_HANDLE service_manager = OpenSCM(SC_MANAGER_ALL_ACCESS);
	if ( service_manager == NULL ) return;

	SC_HANDLE service_handle = OpenService(service_manager, kServiceName, SERVICE_ALL_ACCESS);
	if ( service_handle == NULL )
	{
		spdlog::error("[UninstallMyService] OpenService Failed: 0x{:08x}", GetLastError());
		CloseServiceHandle(service_manager);
		return;
	}

	if ( !DeleteService(service_handle) )
	{
		spdlog::error("[UninstallMyService] DeleteService Failed: 0x{:08x}", GetLastError());
	}

	CloseServiceHandle(service_handle);
	CloseServiceHandle(service_manager);

	spdlog::info("[UninstallMyService] Service uninstalled successfully.");
}

void StartMyService()
{
	SC_HANDLE service_manager = OpenSCM(SC_MANAGER_ALL_ACCESS);
	if ( service_manager == NULL ) return;

	SC_HANDLE service_handle = OpenService(service_manager, kServiceName, SERVICE_ALL_ACCESS);
	if ( service_handle == NULL )
	{
		spdlog::error("[StartMyService] OpenService Failed: 0x{:08x}", GetLastError());
		CloseServiceHandle(service_manager);
		return;
	}

	if ( !StartService(service_handle, 0, NULL) )
	{
		spdlog::error("[StartMyService] StartService Failed: 0x{:08x}", GetLastError());
		CloseServiceHandle(service_handle);
		CloseServiceHandle(service_manager);
		return;
	}

	SERVICE_STATUS service_status;
	QueryServiceStatus(service_handle, &service_status);

	while ( service_status.dwCurrentState != SERVICE_RUNNING )
	{
		Sleep(service_status.dwWaitHint);
		QueryServiceStatus(service_handle, &service_status);
	}

	CloseServiceHandle(service_handle);
	CloseServiceHandle(service_manager);
	spdlog::info("[StartMyService] Service started successfully.");
}

void StopMyService()
{
	SC_HANDLE service_manager = OpenSCM(SC_MANAGER_ALL_ACCESS);
	if ( service_manager == NULL ) return;

	SC_HANDLE service_handle = OpenService(service_manager, kServiceName, SERVICE_ALL_ACCESS);
	if ( service_handle == NULL )
	{
		spdlog::error("[StopMyService] OpenService Failed: 0x{:08x}", GetLastError());
		CloseServiceHandle(service_manager);
		return;
	}

	SERVICE_STATUS service_status;
	QueryServiceStatus(service_handle, &service_status);

	if ( service_status.dwCurrentState != SERVICE_STOPPED )
	{
		if ( !ControlService(service_handle, SERVICE_CONTROL_STOP, &service_status) )
		{
			spdlog::error("[StopMyService] ControlService Failed: 0x{:08x}", GetLastError());
			CloseServiceHandle(service_handle);
			CloseServiceHandle(service_manager);
			return;
		}

		Sleep(2000);
	}

	CloseServiceHandle(service_handle);
	CloseServiceHandle(service_manager);
	spdlog::info("[StopMyService] Service stopped successfully.");
}

int main(int argc, char* argv[])
{
	const std::string log_file_path = "log/Launcher Service.log";
	auto logger = spdlog::basic_logger_mt("basic_logger", log_file_path);
	spdlog::set_level(spdlog::level::trace);
	spdlog::set_default_logger(logger);
	spdlog::flush_on(spdlog::level::trace);

	spdlog::info("Main Start");

	SERVICE_TABLE_ENTRYW service_table[] = {
		{kServiceName, (LPSERVICE_MAIN_FUNCTIONW)ServiceMain},
		{nullptr, nullptr}
	};

	if ( argc >= 2 )
	{
		if ( _stricmp(argv[1], "--install") == 0 )
		{
			InstallMyService();
		}
		else if ( _stricmp(argv[1], "--uninstall") == 0 )
		{
			UninstallMyService();
		}
		else if ( _stricmp(argv[1], "--start") == 0 )
		{
			StartMyService();
		}
		else if ( _stricmp(argv[1], "--stop") == 0 )
		{
			StopMyService();
		}
	}
	else
	{
		StartServiceCtrlDispatcherW(service_table);
	}

	spdlog::info("Main Finish");
	return 0;
}

int _tmain(int argc, TCHAR* argv[]) 
{
    SERVICE_TABLE_ENTRY ServiceTable[] = 
    {
        {TEXT("StudioYS Service"), (LPSERVICE_MAIN_FUNCTION) ServiceMain},
        {NULL, NULL}
    };

    // Start the control dispatcher
    if (!StartServiceCtrlDispatcher(ServiceTable)) 
    {
        // Handle error
    }
}

void WINAPI ServiceMain(DWORD argc, LPTSTR* argv) 
{
    // 1. 서비스 상태 등록
    SERVICE_STATUS_HANDLE hServiceStatus = RegisterServiceCtrlHandler(
        SERVICE_NAME,
        ServiceCtrlHandler
    );

    if (hServiceStatus == NULL) 
    {
        // Error handling
        return;
    }

    // 2. 서비스 상태 보고
    SERVICE_STATUS serviceStatus;
    serviceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
    serviceStatus.dwCurrentState = SERVICE_START_PENDING;
    serviceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE;
    // ...

    SetServiceStatus(hServiceStatus, &serviceStatus);

    // 3. 서비스 동작 수행
    // To Do Something
}

void WINAPI ServiceCtrlHandler(DWORD dwCtrl) 
{
    switch (dwCtrl) {
        case SERVICE_CONTROL_STOP:
            // 서비스 중지 처리
            break;
        case SERVICE_CONTROL_PAUSE:
            // 서비스 일시 중지 처리
            break;
        case SERVICE_CONTROL_CONTINUE:
            // 서비스 재개 처리
            break;
        default:
            break;
    }
}

BOOL SetServiceStatus(
  SERVICE_STATUS_HANDLE hServiceStatus,
  LPSERVICE_STATUS lpServiceStatus
);

SC_HANDLE service_manager = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);

if ( service_manager != NULL )
{
  // To Do Something

  CloseServiceHandle(service_manager);
}

SC_HANDLE service_handle = CreateServiceW(
  service_manager, 
  L"StudioYS Service",
  L"StudioYS Service", 
  SERVICE_ALL_ACCESS, 
  SERVICE_WIN32_SHARE_PROCESS,
  SERVICE_AUTO_START, 
  SERVICE_ERROR_NORMAL, 
  file_path, 
  NULL, NULL, NULL, NULL, NULL);

if ( service_handle != NULL )
{
  // Do Something

  CloseServiceHandle(service_handle);
}

SC_HANDLE service_handle = OpenService(service_manager, L"StudioYS Service", 
  SERVICE_ALL_ACCESS);

if ( service_handle != NULL )
{
  DeleteService(service_handle);
  CloseServiceHandle(service_handle);
}

// 관련 코드
SC_HANDLE service_handle = OpenService(service_manager, L"StudioYS Service", 
  SERVICE_ALL_ACCESS);

if ( service_handle != NULL )
{
  StartService(service_handle, 0, nullptr);
  CloseServiceHandle(service_handle);
}

SC_HANDLE service_handle = OpenService(service_manager, L"StudioYS Service", 
  SERVICE_ALL_ACCESS);

if ( service_handle != NULL )
{
  SERVICE_STATUS service_status;
  ControlService(service_handle, SERVICE_CONTROL_STOP, &service_status);
  CloseServiceH
}

#include <windows.h>
#include "spdlog/spdlog.h"
#include "spdlog/sinks/basic_file_sink.h"

static WCHAR kServiceName[] = L"StudioYS Service";

SC_HANDLE OpenServiceManager(DWORD desiredAccess)
{
    SC_HANDLE service_manager = OpenSCManagerW(NULL, NULL, desiredAccess);
    if ( service_manager == NULL )
    {
        spdlog::error("OpenSCManagerW Failed: 0x{:08X}", GetLastError());
    }
    return service_manager;
}

SC_HANDLE OpenServiceHandle(SC_HANDLE service_manager, DWORD desiredAccess)
{
    SC_HANDLE service_handle = OpenService(service_manager, kServiceName, desiredAccess);
    if ( service_handle == NULL )
    {
        spdlog::error("OpenService Failed: 0x{:08X}", GetLastError());
    }
    return service_handle;
}

void InstallMyService()
{
    spdlog::debug("InstallMyService Start");

    SC_HANDLE service_manager = OpenServiceManager(SC_MANAGER_CREATE_SERVICE);

    if ( service_manager == NULL ) return;

    WCHAR file_path[MAX_PATH] = { 0 };
    GetModuleFileNameW(NULL, file_path, _countof(file_path));

    SC_HANDLE service_handle = CreateServiceW(
        service_manager, kServiceName, kServiceName, SERVICE_ALL_ACCESS,
        SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL,
        file_path, NULL, NULL, NULL, NULL, NULL
    );

    if ( service_handle == NULL )
    {
        spdlog::error("CreateServiceW Failed: 0x{:08X}", GetLastError());
        CloseServiceHandle(service_manager);
        return;
    }

    // 서비스 설명 설정
    WCHAR description[] = L"이 서비스는 테스트를 위한 서비스입니다.";
    SERVICE_DESCRIPTION sd = { description };
    ChangeServiceConfig2W(service_handle, SERVICE_CONFIG_DESCRIPTION, &sd);

    // 핸들 닫기
    CloseServiceHandle(service_handle);
    CloseServiceHandle(service_manager);

    spdlog::debug("InstallMyService Finish");
}

void UninstallMyService()
{
    spdlog::debug("UninstallMyService Start");

    SC_HANDLE service_manager = OpenServiceManager(SC_MANAGER_ALL_ACCESS);
    if ( service_manager == NULL ) return;

    SC_HANDLE service_handle = OpenServiceHandle(service_manager, SERVICE_ALL_ACCESS);
    if ( service_handle == NULL )
    {
        CloseServiceHandle(service_manager);
        return;
    }

    if ( !DeleteService(service_handle) )
    {
        spdlog::error("DeleteService Failed: 0x{:08X}", GetLastError());
    }

    CloseServiceHandle(service_handle);
    CloseServiceHandle(service_manager);

    spdlog::debug("UninstallMyService Finish");
}

void StartMyService()
{
    spdlog::debug("StartMyService Start");

    SC_HANDLE service_manager = OpenServiceManager(SC_MANAGER_ALL_ACCESS);
    if ( service_manager == NULL ) return;

    SC_HANDLE service_handle = OpenServiceHandle(service_manager, SERVICE_START);
    if ( service_handle == NULL )
    {
        CloseServiceHandle(service_manager);
        return;
    }

    if ( !StartService(service_handle, 0, NULL) )
    {
        spdlog::error("StartService Failed: 0x{:08X}", GetLastError());
        CloseServiceHandle(service_handle);
        CloseServiceHandle(service_manager);
        return;
    }

    SERVICE_STATUS service_status;
    BOOL query = QueryServiceStatus(service_handle, &service_status);

    while ( query && service_status.dwCurrentState != SERVICE_RUNNING )
    {
        Sleep(service_status.dwWaitHint);
        query = QueryServiceStatus(service_handle, &service_status);
    }

    CloseServiceHandle(service_handle);
    CloseServiceHandle(service_manager);

    spdlog::debug("StartMyService Finish");
}

void StopMyService()
{
    spdlog::debug("StopMyService Start");

    SC_HANDLE service_manager = OpenServiceManager(SC_MANAGER_ALL_ACCESS);

    if ( service_manager == NULL ) return;

    SC_HANDLE service_handle = OpenServiceHandle(service_manager, SERVICE_STOP);

    if ( service_handle == NULL )
    {
        CloseServiceHandle(service_manager);
        return;
    }

    SERVICE_STATUS service_status;

    BOOL query = QueryServiceStatus(service_handle, &service_status);

    if ( query && service_status.dwCurrentState != SERVICE_STOPPED )
    {
        if ( !ControlService(service_handle, SERVICE_CONTROL_STOP, &service_status) )
        {
            spdlog::error("ControlService Failed: 0x{:08X}", GetLastError());
        }
        Sleep(2000);
    }

    CloseServiceHandle(service_handle);
    CloseServiceHandle(service_manager);

    spdlog::debug("StopMyService Finish");
}

int wmain(int argc, wchar_t* argv[])
{
    // logger 설정
    auto logger = spdlog::basic_logger_mt("StudioYS Service", "log/StudioYS_Service.log");
    spdlog::set_default_logger(logger);
    spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e (P:%P T:%t) [%L][%n] %v");
    spdlog::set_level(spdlog::level::debug);
    spdlog::flush_on(spdlog::level::debug);

    if ( argc >= 2 )
    {
        if ( _wcsicmp(argv[1], L"--install") == 0 )
        {
            InstallMyService();
        }
        else if ( _wcsicmp(argv[1], L"--uninstall") == 0 )
        {
            UninstallMyService();
        }
        else if ( _wcsicmp(argv[1], L"--start") == 0 )
        {
            StartMyService();
        }
        else if ( _wcsicmp(argv[1], L"--stop") == 0 )
        {
            StopMyService();
        }
        else
        {
            spdlog::error("Unknown command");
        }
    }
    else
    {
        spdlog::error("No command provided.");
    }

    return 0;
}

#include "spdlog/spdlog.h"
  
int main()
{
    spdlog::info("Welcome to spdlog!");
    spdlog::info("Args : {}", 42);
    spdlog::info("Between {1} and {0}", "Z", 0);
    spdlog::info("Notation Formatting int: {0:d}, hex: {0:x}, oct: {0:o}, bin: {0:b}", 42);
    spdlog::info("Padding 1 : {:8d}", 5);
    spdlog::info("Padding 2 : {:08x}", 5);
    spdlog::info("{:<30}", "left aligned");
    spdlog::info("{:>30}", "right aligned");
    spdlog::info("Floating 1 : {:08.1f}", 1.23456);
    spdlog::info("Floating 2 : {:08.2f}", 1.23456);
    spdlog::info("Floating 3 : {:8.1f}", 1.23456);
    spdlog::info("Floating 4 : {:8.2f}", 1.23456);
    
    spdlog::set_pattern("%^%l: %v%$");
 
    return 0;
}

spdlog::set_pattern(pattern_string)

// Level: 로그 형태로 출력
spdlog::set_pattern("%^%l: %v%$");

// *** [12:53:29 +09:00] [thread 17340] 로그 ** 형태로 출력
spdlog::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***");

#include "spdlog/spdlog.h"
 
int main()
{
    spdlog::set_level(spdlog::level::err);
    spdlog::trace("Trace Level");
    spdlog::debug("Debug Level");
    spdlog::info("Info Level");
    spdlog::warn("Warn Level");
    spdlog::error("Error Level");
    spdlog::critical("Critical Level");
 
    return 0;
}

#include "spdlog/spdlog.h"
 
#pragma comment(lib, "libspdlog_MD_2019_x86D_v1.10.0.lib")
 
int main()
{
    SPDLOG_TRACE("Trace Level");
    SPDLOG_DEBUG("Debug Level");
    SPDLOG_INFO("Info Level");
    SPDLOG_WARN("Warn Level");
    SPDLOG_ERROR("Error Level");
    SPDLOG_CRITICAL("Critical Level");
 
    return 0;
}

#include "spdlog/spdlog.h"
#include "spdlog/sinks/basic_file_sink.h"

int main()
{
    auto logger = spdlog::basic_logger_mt("basic_logger", "logs/basic.txt");
    
    spdlog::set_default_logger(logger);
    spdlog::info("Basic File Logger");
    
    return 0;
}

#include "spdlog/spdlog.h"
#include "spdlog/sinks/rotating_file_sink.h"
 
int main()
{
    auto max_size = 5 * 1024 * 1024;
    auto max_files = 3;
    
    // 5MB 넘어갈 경우 파일을 생성. 3개 파일을 반복하여 사용
    auto logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", max_size, max_files);

    spdlog::set_default_logger(logger);
    spdlog::info("Rotating File Logger");
 
    return 0;
}

#include "spdlog/spdlog.h"
#include "spdlog/sinks/daily_file_sink.h"
 
int main()
{
    auto hour = 2;
    auto min = 30;
    
    // daily_YYYY-MM-DD.txt 파일 생성 ( 새벽 2시 30분에 )
    auto logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", hour, min);
 
    spdlog::set_default_logger(logger);
    spdlog::info("Daily File Logger");
 
    return 0;
}

spdlog::flush_every(std::chrono::seconds(3));  // 3초마다 갱신
spdlog::flush_on(spdlog::level::trace);        // trace 이상 항상 갱신

spdlog::enable_backtrace(10);

for(int i = 0; i < 100; i++)
{
  spdlog::debug("Backtrace message {}", i); // not logged yet..
}

spdlog::dump_backtrace();

git clone https://github.com/gabime/spdlog.git

# spdlog 소스 폴더로 이동
cd spdlog

# x86용 build 폴더 생성
mkdir build

# x64용 build 폴더 생성
mkdir build64

# CMake를 사용하여 빌드 프로젝트 생성하기
cmake CMakeLists.txt -B [빌드 프로젝트 경로] -G [Generator] -A [Architecture]
 
# Visual Studio 2022 - x86
cmake CMakeLists.txt -B build -G "Visual Studio 17 2022" -A Win32
 
# Visual Studio 2022 - x64
cmake CMakeLists.txt -B build64 -G "Visual Studio 17 2022" -A x64

#include <iostream>
#include "spdlog/spdlog.h"
  
int main()
{
    spdlog::info("Hello World!\n");
 
    return 0;
}

#include <windows.h>
#include <d3d11.h>

#include <memory>
#include <string>
#include <algorithm>

#pragma pack(push,1)

#define DDS_MAGIC 0x20534444 // "DDS "

#define DDS_FOURCC      0x00000004  // DDPF_FOURCC
#define DDS_RGB         0x00000040  // DDPF_RGB
#define DDS_RGBA        0x00000041  // DDPF_RGB | DDPF_ALPHAPIXELS
#define DDS_LUMINANCE   0x00020000  // DDPF_LUMINANCE
#define DDS_LUMINANCEA  0x00020001  // DDPF_LUMINANCE | DDPF_ALPHAPIXELS
#define DDS_ALPHA       0x00000002  // DDPF_ALPHA
#define DDS_BUMPDUDV    0x00080000  // DDPF_BUMPDUDV

#define DDS_HEADER_FLAGS_TEXTURE        0x00001007  // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
#define DDS_HEADER_FLAGS_MIPMAP         0x00020000  // DDSD_MIPMAPCOUNT
#define DDS_HEADER_FLAGS_PITCH          0x00000008  // DDSD_PITCH
#define DDS_HEADER_FLAGS_LINEARSIZE     0x00080000  // DDSD_LINEARSIZE

#define DDS_SURFACE_FLAGS_TEXTURE 0x00001000 // DDSCAPS_TEXTURE

struct DDS_PIXELFORMAT {
  DWORD dwSize;
  DWORD dwFlags;
  DWORD dwFourCC;
  DWORD dwRGBBitCount;
  DWORD dwRBitMask;
  DWORD dwGBitMask;
  DWORD dwBBitMask;
  DWORD dwABitMask;
};

typedef struct {
  DWORD           dwSize;
  DWORD           dwFlags;
  DWORD           dwHeight;
  DWORD           dwWidth;
  DWORD           dwPitchOrLinearSize;
  DWORD           dwDepth;
  DWORD           dwMipMapCount;
  DWORD           dwReserved1[11];
  DDS_PIXELFORMAT ddspf;
  DWORD           dwCaps;
  DWORD           dwCaps2;
  DWORD           dwCaps3;
  DWORD           dwCaps4;
  DWORD           dwReserved2;
} DDS_HEADER;

typedef struct {
  DXGI_FORMAT              dxgiFormat;
  D3D10_RESOURCE_DIMENSION resourceDimension;
  UINT                     miscFlag;
  UINT                     arraySize;
  UINT                     miscFlags2;
} DDS_HEADER_DXT10;

#pragma pack(pop)

const DDS_PIXELFORMAT DDSPF_A8R8G8B8 =
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 };

struct com_deleter { void operator()(IUnknown* p) { if ( p ) { p->Release(); } } };
struct handle_closer { void operator()(HANDLE h) { if ( h != INVALID_HANDLE_VALUE ) CloseHandle(h); } };

template <typename T> using ScopedInterface = std::unique_ptr<T, com_deleter>;
template <typename T> ScopedInterface<T> make_com_ptr(T* p) { return ScopedInterface<T>(p); }

using ScopedHandle = std::unique_ptr<void, handle_closer>;
inline HANDLE safe_handle(HANDLE h) { return (h == INVALID_HANDLE_VALUE) ? nullptr : h; }

HRESULT SaveDDSFile(ID3D11DeviceContext* device_context, ID3D11Resource* source, const wchar_t* file_name)
{
  if ( nullptr == device_context || nullptr == source || nullptr == file_name )
  {
    return E_INVALIDARG;
  }

  D3D11_RESOURCE_DIMENSION resource_type = D3D11_RESOURCE_DIMENSION_UNKNOWN;
  source->GetType(&resource_type);

  if ( resource_type != D3D11_RESOURCE_DIMENSION_TEXTURE2D )
  {
    return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
  }

  ID3D11Texture2D* source_texture = nullptr;

  HRESULT hr = source->QueryInterface(__uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&source_texture));

  if ( FAILED(hr) )
  {
    return hr;
  }

  auto _source_texture = make_com_ptr(source_texture);

  D3D11_TEXTURE2D_DESC desc;
  source_texture->GetDesc(&desc);

  ID3D11Device* device = nullptr;
  device_context->GetDevice(&device);

  auto _device = make_com_ptr(device);

  if ( desc.SampleDesc.Count != 1 && desc.Format != DXGI_FORMAT_B8G8R8A8_UNORM )
  {
    return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
  }

  ID3D11Texture2D* staging_texture = nullptr;

  ScopedInterface<ID3D11Texture2D> _staging_texture;

  if ( (desc.Usage == D3D11_USAGE_STAGING) && (desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ) )
  {
    staging_texture = source_texture;
    _staging_texture = std::move(_source_texture);
  }
  else
  {
    desc.BindFlags = 0;
    desc.MiscFlags = 0;
    desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
    desc.Usage = D3D11_USAGE_STAGING;

    hr = device->CreateTexture2D(&desc, nullptr, &staging_texture);

    if ( FAILED(hr) )
    {
      return hr;
    }

    device_context->CopyResource(staging_texture, source_texture);

    _staging_texture = make_com_ptr(staging_texture);
  }

  const DWORD kMaxHeaderSize = sizeof(DWORD) + sizeof(DDS_HEADER) + sizeof(DDS_HEADER_DXT10);
  BYTE file_header[kMaxHeaderSize] = {};

  *reinterpret_cast<DWORD*>(&file_header[0]) = DDS_MAGIC;

  auto header = reinterpret_cast<DDS_HEADER*>(&file_header[0] + sizeof(DWORD));
  size_t header_size = sizeof(DWORD) + sizeof(DDS_HEADER);
  header->dwSize = sizeof(DDS_HEADER);
  header->dwFlags = DDS_HEADER_FLAGS_TEXTURE | DDS_HEADER_FLAGS_MIPMAP;
  header->dwHeight = desc.Height;
  header->dwWidth = desc.Width;
  header->dwMipMapCount = 1;
  header->dwCaps = DDS_SURFACE_FLAGS_TEXTURE;

  DDS_HEADER_DXT10* ext_header = nullptr;
  memcpy_s(&header->ddspf, sizeof(header->ddspf), &DDSPF_A8R8G8B8, sizeof(DDS_PIXELFORMAT));

  DWORD row_pitch = (DWORD(desc.Width) * 32 + 7u) / 8u;
  DWORD row_count = (DWORD(desc.Height));
  DWORD row_bytes = row_pitch * row_count;

  header->dwFlags |= DDS_HEADER_FLAGS_PITCH;
  header->dwPitchOrLinearSize = static_cast<DWORD>(row_pitch);

  std::unique_ptr<BYTE[]> pixels(new (std::nothrow) BYTE[row_bytes]);

  if ( !pixels )
  {
    return E_OUTOFMEMORY;
  }

  D3D11_MAPPED_SUBRESOURCE resource;

  hr = device_context->Map(staging_texture, 0, D3D11_MAP_READ, 0, &resource);

  if ( FAILED(hr) )
  {
    return hr;
  }

  auto src_data = static_cast<const BYTE*>(resource.pData);

  if ( !src_data )
  {
    device_context->Unmap(staging_texture, 0);
    return E_POINTER;
  }

  BYTE* dst_ptr = pixels.get();

  const DWORD min_size = std::min<DWORD>(row_pitch, resource.RowPitch);

  for ( DWORD h = 0; h < row_count; ++h )
  {
    memcpy_s(dst_ptr, row_pitch, src_data, min_size);
    src_data += resource.RowPitch;
    dst_ptr += row_pitch;
  }

  device_context->Unmap(staging_texture, 0);

  ScopedHandle hFile(safe_handle(CreateFileW(file_name, GENERIC_WRITE | DELETE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr)));

  if ( !hFile )
  {
    return HRESULT_FROM_WIN32(GetLastError());
  }

  DWORD bytesWritten;
  if ( !WriteFile(hFile.get(), file_header, static_cast<DWORD>(header_size), &bytesWritten, nullptr) )
  {
    return HRESULT_FROM_WIN32(GetLastError());
  }

  if ( bytesWritten != header_size )
  {
    return E_FAIL;
  }

  if ( !WriteFile(hFile.get(), pixels.get(), static_cast<DWORD>(row_bytes), &bytesWritten, nullptr) )
  {
    return HRESULT_FROM_WIN32(GetLastError());
  }

  if ( bytesWritten != row_bytes )
  {
    return E_FAIL;
  }

  return S_OK;
}

BOOL IsObscuredWindow(HWND hwnd)
{
    if (hwnd == NULL) return FALSE;

    BOOL is_obscured = FALSE;
    HWND current_window = hwnd;

    // 대상 윈도우의 영역 가져오기
    RECT target_rect;
    if (!GetWindowRect(hwnd, &target_rect)) return FALSE;
    HRGN target_region = CreateRectRgnIndirect(&target_rect);
    if (target_region == NULL) return FALSE;

    // 상위 윈도우를 탐색하면서 영역 비교
    while ((current_window = GetNextWindow(current_window, GW_HWNDPREV)) != NULL)
    {
        // 상위 윈도우가 보이지 않으면 건너뛴다
        if (!IsWindowVisible(current_window)) continue;

        // 상위 윈도우의 확장 스타일 가져오기
        LONG_PTR style = GetWindowLongPtrW(current_window, GWL_EXSTYLE);

        // 투명 또는 레이어된 윈도우는 무시
        if (style & (WS_EX_LAYERED | WS_EX_NOREDIRECTIONBITMAP | WS_EX_TRANSPARENT)) continue;

        // 상위 윈도우의 영역 가져오기
        RECT current_rect;
        if (!GetWindowRect(current_window, current_rect)) continue;

        // 영역 생성 및 비교
        HRGN current_region = CreateRectRgnIndirect(current_rect);
        if (current_region == NULL) continue;

        // 두 윈도우 영역 비교
        int combine_result = CombineRgn(target_region, target_region, current_region, RGN_DIFF);
        DeleteObject(current_region);

        // 대상 윈도우가 완전히 가려졌을 때
        if (combine_result == NULLREGION)
        {
            is_obscured = TRUE;
            break;
        }
    }

    // 메모리 해제
    DeleteObject(target_region);

    return is_obscured;
}