// toolDlg.cpp: 구현 파일
//

#include "pch.h"
#include "framework.h"
#include "tool.h"
#include "toolDlg.h"
#include "afxdialogex.h"

#include <string>

Bs1fltControl bs1flt_;

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// 응용 프로그램 정보에 사용되는 CAboutDlg 대화 상자입니다.

class CAboutDlg : public CDialogEx
{
public:
	CAboutDlg();

// 대화 상자 데이터입니다.
#ifdef AFX_DESIGN_TIME
	enum { IDD = IDD_ABOUTBOX };
#endif

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 지원입니다.

// 구현입니다.
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()


// CtoolDlg 대화 상자



CtoolDlg::CtoolDlg(CWnd* pParent /*=nullptr*/)
	: CDialogEx(IDD_TOOL_DIALOG, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CtoolDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST1, listLog_);
	DDX_Control(pDX, IDC_EDIT_DEBUG, editDebug_);
}

BEGIN_MESSAGE_MAP(CtoolDlg, CDialogEx)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON_START, &CtoolDlg::OnBnClickedButtonStart)
	ON_BN_CLICKED(IDC_BUTTON_STOP, &CtoolDlg::OnBnClickedButtonStop)
	ON_BN_CLICKED(IDC_BUTTON_USB_REMOVAL_SET_POLICY, &CtoolDlg::OnBnClickedButtonSetPolicy)
	ON_BN_CLICKED(IDCANCEL, &CtoolDlg::OnBnClickedCancel)
	ON_BN_CLICKED(IDC_BUTTON_PROCESS_PROTECT, &CtoolDlg::OnBnClickedButtonProcessProtect)
	ON_MESSAGE(WM_UPDATE_LOG_MSG, &CtoolDlg::OnUpdateLog)
	ON_BN_CLICKED(IDC_BUTTON_USB_EXCEPTION, &CtoolDlg::OnBnClickedButtonUsbException)
	ON_BN_CLICKED(IDC_BUTTON_DEVICE_PROTECT, &CtoolDlg::OnBnClickedButtonDeviceProtect)
	ON_BN_CLICKED(IDC_BUTTON2, &CtoolDlg::OnBnClickedButton2)
	ON_BN_CLICKED(IDC_BUTTON_SET_USB_HOOK, &CtoolDlg::OnBnClickedButtonSetUsbHook)
	ON_BN_CLICKED(IDC_BUTTON_SET_BLUETOOTH_HOOK, &CtoolDlg::OnBnClickedButtonSetBluetoothHook)
	ON_BN_CLICKED(IDC_BUTTON_SET_MTP_HOOK, &CtoolDlg::OnBnClickedButtonSetMtpHook)
	ON_BN_CLICKED(IDC_BUTTON3, &CtoolDlg::OnBnClickedButton3)
	ON_BN_CLICKED(IDC_BUTTON_INIT, &CtoolDlg::OnBnClickedButtonInit)
	ON_BN_CLICKED(IDC_BUTTON_OPEN, &CtoolDlg::OnBnClickedButtonOpen)
	ON_BN_CLICKED(IDC_BUTTON_FOLDER_SETTING, &CtoolDlg::OnBnClickedButtonFolderSetting)
	ON_BN_CLICKED(IDC_BUTTON_REGDIT_SETTING, &CtoolDlg::OnBnClickedButtonRegditSetting)
END_MESSAGE_MAP()


BOOL RegeditMessageMsg(DWORD msg)
{
	BOOL	bRet = FALSE;
	TCHAR szModulePath[MAX_PATH] = { 0, };


	typedef	BOOL(WINAPI* fn_ChangeWindowmessageFilter)(UINT message, DWORD dwFlag);
	fn_ChangeWindowmessageFilter ChangeWindowMsgFilter_ = NULL;


	::GetSystemDirectory(szModulePath, MAX_PATH - 1);
	_tcscat(szModulePath, _T("\\user32.dll"));

	HMODULE h = NULL;
	h = ::LoadLibrary(szModulePath);

	if (!h)
		return FALSE;

	ChangeWindowMsgFilter_ = (fn_ChangeWindowmessageFilter)GetProcAddress(h, "ChangeWindowMessageFilter");
	if (ChangeWindowMsgFilter_ != NULL)
	{
		bRet = ChangeWindowMsgFilter_(msg, MSGFLT_ADD);
	}

	bRet = TRUE;

	if (h)
	{
		FreeLibrary(h);
		h = NULL;
	}

	return bRet;
}


DWORD WINAPI Report(PVOID context)
{
	
	if (context == NULL) return 0;

	//CString* pLogString = new CString((WCHAR*)context);

	//CWnd* pMainWnd = AfxGetMainWnd();
	//if (pMainWnd && pMainWnd->GetSafeHwnd())
	//{
	//	::PostMessage(pMainWnd->GetSafeHwnd(), WM_UPDATE_LOG_MSG, 0, (LPARAM)pLogString);
	//}
	//else
	//{
	//	delete pLogString;
	//}

	
	CString pLogString = (WCHAR*)context;
	OutputDebugStringW(pLogString.GetBuffer(0));
	int idx = theApp.dlg.listLog_.AddString(pLogString);

	return 0;

}

LRESULT CtoolDlg::OnUpdateLog(WPARAM wParam, LPARAM lParam)
{
	// 1. lParam을 다시 CString 포인터로 캐스팅
	CString* pLogString = (CString*)lParam;

	if (pLogString)
	{
		// 2. 리스트 컨트롤에 추가 (여기는 UI 쓰레드라 안전함)
		// theApp.listLog_ 대신 현재 클래스의 멤버 변수(m_listLog)를 쓰는 것이 일반적입니다.
		// 만약 theApp에 있다면 theApp.listLog_.AddString(*pLogString); 도 가능합니다.

		// 예: 리스트 박스인 경우
		int idx = listLog_.AddString(*pLogString);
		listLog_.SetCurSel(idx); // 오토 스크롤

		// 3. **중요** 할당했던 메모리 해제
		delete pLogString;
	}

	return 0;
}

// CtoolDlg 메시지 처리기
BOOL CtoolDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	// 시스템 메뉴에 "정보..." 메뉴 항목을 추가합니다.

	// IDM_ABOUTBOX는 시스템 명령 범위에 있어야 합니다.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != nullptr)
	{
		BOOL bNameValid;
		CString strAboutMenu;
		bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
		ASSERT(bNameValid);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	device_protect_ = FALSE;
	// 이 대화 상자의 아이콘을 설정합니다.  응용 프로그램의 주 창이 대화 상자가 아닐 경우에는
	//  프레임워크가 이 작업을 자동으로 수행합니다.
	SetIcon(m_hIcon, TRUE);			// 큰 아이콘을 설정합니다.
	SetIcon(m_hIcon, FALSE);		// 작은 아이콘을 설정합니다.

	// TODO: 여기에 추가 초기화 작업을 추가합니다.
	RegeditMessageMsg(WM_COPYDATA);

	WCHAR dllpath[MAX_PATH] = { 0, };
	WCHAR buffer[MAX_PATH] = { 0, };
	DWORD state = 0;

	GetModuleFileNameW(NULL, dllpath, ARRAYSIZE(dllpath));
	WCHAR* ptr = wcsrchr(dllpath, L'\\');
	if (!ptr)
		return TRUE;

	*ptr = '\0';
	s_wcurrent_path_ = dllpath;

	state = bs1flt_.Init(s_wcurrent_path_.c_str(), Report);
	if(state != ERROR_SUCCESS)
	{
		MessageBoxW(L"Bs1fltControl 초기화 실패", L"Error", MB_ICONERROR);
	}

	return TRUE;  // 포커스를 컨트롤에 설정하지 않으면 TRUE를 반환합니다.
}

void CtoolDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialogEx::OnSysCommand(nID, lParam);
	}
}

// 대화 상자에 최소화 단추를 추가할 경우 아이콘을 그리려면
//  아래 코드가 필요합니다.  문서/뷰 모델을 사용하는 MFC 애플리케이션의 경우에는
//  프레임워크에서 이 작업을 자동으로 수행합니다.

void CtoolDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // 그리기를 위한 디바이스 컨텍스트입니다.

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// 클라이언트 사각형에서 아이콘을 가운데에 맞춥니다.
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// 아이콘을 그립니다.
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

// 사용자가 최소화된 창을 끄는 동안에 커서가 표시되도록 시스템에서
//  이 함수를 호출합니다.
HCURSOR CtoolDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}


void CtoolDlg::OnBnClickedButtonStart()
{
	bs1flt_.Bs1FltFolderProtectControl(TRUE);
}


void CtoolDlg::OnBnClickedButtonStop()
{
	bs1flt_.Bs1FltFolderProtectControl(FALSE);
}

void CtoolDlg::OnBnClickedButtonSetPolicy()
{
	DWORD devcie_type = 0;
	DWORD state = ENABLE;
	BOOL islog = FALSE;
	CString debug;

	DEVICE_POLICY policy[BDC_MAX_DEVICE_TYPE];

	for(int i = 0; i < BDC_MAX_DEVICE_TYPE; i++)
	{
		policy[i].device_type = BDC_UNKNOWN_DEV;
		policy[i].state = ENABLE;
		policy[i].islog = FALSE;
	}

	policy[BDC_USB_DISK].device_type = BDC_USB_DISK;
	if (((CButton*)GetDlgItem(IDC_RADIO_USB_REMOVAL_DISABLE))->GetCheck())
	{
		state = (DWORD)DISABLE;
		debug.Format(L"IDC_RADIO_USB_REMOVAL_DISABLE");
		listLog_.AddString(debug);		
		policy[BDC_USB_DISK].state = (enum_devicestate)DISABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_USB_REMOVAL_ENABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO_USB_REMOVAL_ENABLE");
		listLog_.AddString(debug);		
		policy[BDC_USB_DISK].state = (enum_devicestate)ENABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_USB_REMOVAL_LOG_ENABLE))->GetCheck())
	{
		islog = (DWORD)TRUE;
		debug.Format(L"IDC_RADIO_USB_REMOVAL_LOG_ENABLE");
		listLog_.AddString(debug);		
		policy[BDC_USB_DISK].islog = TRUE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_USB_REMOVAL_LOG_DISABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO_USB_REMOVAL_LOG_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_USB_DISK].islog = FALSE;
	}

	///
	policy[BDC_EXTERNALHDD].device_type = BDC_EXTERNALHDD;
	if (((CButton*)GetDlgItem(IDC_RADIO_EXTERNAL_DISABLE))->GetCheck())
	{
		state = (DWORD)DISABLE;
		debug.Format(L"IDC_RADIO_EXTERNAL_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_EXTERNALHDD].state = (enum_devicestate)DISABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_EXTERNAL_ENABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO_EXTERNAL_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_EXTERNALHDD].state = (enum_devicestate)ENABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_EXTERNAL_LOG_ENABLE))->GetCheck())
	{
		islog = (DWORD)TRUE;
		debug.Format(L"IDC_RADIO_EXTERNAL_LOG_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_EXTERNALHDD].islog = TRUE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_EXTERNAL_LOG_DISABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO_EXTERNAL_LOG_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_EXTERNALHDD].islog = FALSE;
	}

	///
	policy[BDC_NETWORKSHAREOUT].device_type = BDC_NETWORKSHAREOUT;
	if (((CButton*)GetDlgItem(IDC_RADIO_NETWORKOUT_DISABLE))->GetCheck())
	{
		state = (DWORD)DISABLE;
		debug.Format(L"IDC_RADIO_NETWORKOUT_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_NETWORKSHAREOUT].state = (enum_devicestate)DISABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_NETWORKOUT_ENABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO_NETWORKOUT_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_NETWORKSHAREOUT].state = (enum_devicestate)ENABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_NETWORKOUT_LOG_ENABLE))->GetCheck())
	{
		islog = (DWORD)TRUE;
		debug.Format(L"IDC_RADIO_NETWORKOUT_LOG_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_NETWORKSHAREOUT].islog = TRUE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_NETWORKOUT_LOG_DISABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO_NETWORKOUT_LOG_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_NETWORKSHAREOUT].islog = FALSE;
	}
	
	///
	policy[BDC_NETWORKDRIVEIN].device_type = BDC_NETWORKDRIVEIN;
	if (((CButton*)GetDlgItem(IDC_RADIO_NETWORKIN_DISABLE))->GetCheck())
	{
		state = (DWORD)DISABLE;
		debug.Format(L"IDC_RADIO_NETWORKIN_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_NETWORKDRIVEIN].state = (enum_devicestate)DISABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_NETWORKIN_ENABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO_NETWORKIN_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_NETWORKDRIVEIN].state = (enum_devicestate)ENABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO11_NETWORKIN_LOG_DISABLE))->GetCheck())
	{
		islog = (DWORD)TRUE;
		debug.Format(L"IDC_RADIO11_NETWORKIN_LOG_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_NETWORKDRIVEIN].islog = TRUE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO11_NETWORKIN_LOG_DISABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO11_NETWORKIN_LOG_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_NETWORKDRIVEIN].islog = FALSE;
	}

	///
	policy[BDC_CDROM].device_type = BDC_CDROM;
	if (((CButton*)GetDlgItem(IDC_RADIO12_CDROM_DISABLE))->GetCheck())
	{
		state = (DWORD)DISABLE;
		debug.Format(L"IDC_RADIO12_CDROM_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_CDROM].state = (enum_devicestate)DISABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO13_CDROM_ENABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO13_CDROM_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_CDROM].state = (enum_devicestate)ENABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO14_CDROM_LOG_ENABLE))->GetCheck())
	{
		islog = (DWORD)TRUE;
		debug.Format(L"IDC_RADIO14_CDROM_LOG_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_CDROM].islog = TRUE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO15_CDROM_LOG_DISABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO15_CDROM_LOG_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_CDROM].islog = FALSE;
	}

	///
	policy[BDC_FLOOPY].device_type = BDC_FLOOPY;
	if (((CButton*)GetDlgItem(IDC_RADIO16_FLOPPYDISK_DISABLE))->GetCheck())
	{
		state = (DWORD)DISABLE;
		debug.Format(L"IDC_RADIO16_FLOPPYDISK_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_FLOOPY].state = (enum_devicestate)DISABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO17_FLOPPYDISK_ENABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO17_FLOPPYDISK_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_FLOOPY].state = (enum_devicestate)ENABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO18_FLOPPYDISK_LOG_ENABLE))->GetCheck())
	{
		islog = (DWORD)TRUE;
		debug.Format(L"IDC_RADIO18_FLOPPYDISK_LOG_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_FLOOPY].islog = TRUE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO19_FLOPPYDISK_LOG_DISABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO19_FLOPPYDISK_LOG_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_FLOOPY].islog = FALSE;
	}

	policy[BDC_USB].device_type = BDC_USB;
	if (((CButton*)GetDlgItem(IDC_RADIO16_USBPORT_DISABLE))->GetCheck())
	{
		state = (DWORD)DISABLE;
		debug.Format(L"IDC_RADIO16_USBPORT_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_USB].state = (enum_devicestate)DISABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO17_USBPORT_ENABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO17_USBPORT_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_USB].state = (enum_devicestate)ENABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO18_USBPORT_LOG_ENABLE))->GetCheck())
	{
		islog = (DWORD)TRUE;
		debug.Format(L"IDC_RADIO18_USBPORT_LOG_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_USB].islog = TRUE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO19_USBPORT_LOG_DISABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO19_USBPORT_LOG_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_USB].islog = FALSE;
	}
	//블루투스
	policy[BDC_BLUETOOTH].device_type = BDC_BLUETOOTH;
	if (((CButton*)GetDlgItem(IDC_RADIO_BLUETOOTHPORT_DISABLE))->GetCheck())
	{
		state = (DWORD)DISABLE;
		debug.Format(L"IDC_RADIO_BLUETOOTHPORT_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_BLUETOOTH].state = (enum_devicestate)DISABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_BLUETOOTHPORT_ENABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO_BLUETOOTHPORT_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_BLUETOOTH].state = (enum_devicestate)ENABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_BLUETOOTHPORT_LOG_ENABLE))->GetCheck())
	{
		islog = (DWORD)TRUE;
		debug.Format(L"IDC_RADIO_BLUETOOTHPORT_LOG_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_BLUETOOTH].islog = TRUE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_BLUETOOTHPORT_LOG_DISABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO_BLUETOOTHPORT_LOG_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_BLUETOOTH].islog = FALSE;
	}

	//블루투스 파일
	policy[BDC_BLUETOOTH_FILE].device_type = BDC_BLUETOOTH_FILE;
	if (((CButton*)GetDlgItem(IDC_RADIO_BLUETOOTHFILEPORT_DISABLE))->GetCheck())
	{
		state = (DWORD)DISABLE;
		debug.Format(L"IDC_RADIO_BLUETOOTHFILEPORT_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_BLUETOOTH_FILE].state = (enum_devicestate)DISABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_BLUETOOTHFILEPORT_ENABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO_BLUETOOTHFILEPORT_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_BLUETOOTH_FILE].state = (enum_devicestate)ENABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_BLUETOOTHFILEPORT_LOG_ENABLE))->GetCheck())
	{
		islog = (DWORD)TRUE;
		debug.Format(L"IDC_RADIO_BLUETOOTHFILEPORT_LOG_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_BLUETOOTH_FILE].islog = TRUE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_BLUETOOTHFILEPORT_LOG_DISABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO_BLUETOOTHFILEPORT_LOG_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_BLUETOOTH_FILE].islog = FALSE;
	}

	//MTP
	policy[BDC_MTP].device_type = BDC_MTP;
	if (((CButton*)GetDlgItem(IDC_RADIO_MTPPORT_DISABLE))->GetCheck())
	{
		state = (DWORD)DISABLE;
		debug.Format(L"IDC_RADIO_MTPPORT_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_MTP].state = (enum_devicestate)DISABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_MTPPORT_ENABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO_MTPPORT_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_MTP].state = (enum_devicestate)ENABLE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_MTPPORT_LOG_ENABLE))->GetCheck())
	{
		islog = (DWORD)TRUE;
		debug.Format(L"IDC_RADIO_MTPPORT_LOG_ENABLE");
		listLog_.AddString(debug);
		policy[BDC_MTP].islog = TRUE;
	}

	if (((CButton*)GetDlgItem(IDC_RADIO_MTPPORT_LOG_DISABLE))->GetCheck())
	{
		debug.Format(L"IDC_RADIO_MTPPORT_LOG_DISABLE");
		listLog_.AddString(debug);
		policy[BDC_MTP].islog = FALSE;
	}

	for (int i = 0; i < BDC_MAX_DEVICE_TYPE; i++)
	{
		if(policy[i].device_type == BDC_UNKNOWN_DEV)
			continue;

		debug.Format(L"SetPolicy : Device Type %d State %d Islog %d", policy[i].device_type, policy[i].state, policy[i].islog);
		listLog_.AddString(debug);
		bs1flt_.Bs1FltSetPolicy((DWORD)policy[i].device_type, policy[i].state, policy[i].islog);
	}

	/*debug.Format(L"SetPolicy : %d %d", state, islog);
	listLog_.AddString(debug);

	bs1flt_.Bs1FltSetPolicy((DWORD)BDC_USB_DISK, state, islog);*/

}

void CtoolDlg::OnBnClickedCancel()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.

	bs1flt_.Bs1FltCleanup();

	CDialogEx::OnCancel();
}

void CtoolDlg::OnBnClickedButtonProcessProtect()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	CDialogProtectProcess dlg;
	dlg.DoModal();
}

void CtoolDlg::OnBnClickedButtonUsbException()
{
	CDialogUsbException	dlg;

	dlg.DoModal();
}

void CtoolDlg::OnBnClickedButtonDeviceProtect()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	if (!device_protect_)
		device_protect_ = TRUE;
	else
		device_protect_ = FALSE;

	bs1flt_.Bs1fltSetDeviceProtect(device_protect_);
	
	if(device_protect_)
		GetDlgItem(IDC_BUTTON_DEVICE_PROTECT)->SetWindowTextW(L"장치 제어 중지");
	else
		GetDlgItem(IDC_BUTTON_DEVICE_PROTECT)->SetWindowTextW(L"장치 제어 시작");
}

void CtoolDlg::OnBnClickedButton2()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	CString input;
	editDebug_.GetWindowTextW(input);

	int value = _ttoi(input); // input이 "123"이면 value는 123이 됨
	bs1flt_.Bs1FltDebug(value);
}

static BOOL isUsbhook = FALSE;
static BOOL isBlueToothhook = FALSE;
static BOOL isMtphook = FALSE;
void CtoolDlg::OnBnClickedButtonSetUsbHook()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	//IDC_BUTTON_SET_USB_HOOK
	if(isUsbhook)
		isUsbhook = FALSE;
	else
		isUsbhook = TRUE;

	bs1flt_.Bs1FltSetHook(BDC_USB, isUsbhook);
	
	if(isUsbhook)
		GetDlgItem(IDC_BUTTON_SET_USB_HOOK)->SetWindowTextW(L"USB 후킹 해제");
	else
		GetDlgItem(IDC_BUTTON_SET_USB_HOOK)->SetWindowTextW(L"USB 후킹 시작");
	
}

void CtoolDlg::OnBnClickedButtonSetBluetoothHook()
{
	if (isBlueToothhook)
		isBlueToothhook = FALSE;
	else
		isBlueToothhook = TRUE;

	bs1flt_.Bs1FltSetHook(BDC_BLUETOOTH, isBlueToothhook);

	if (isBlueToothhook)
		GetDlgItem(IDC_BUTTON_SET_BLUETOOTH_HOOK)->SetWindowTextW(L"블루투스 후킹 해제");
	else
		GetDlgItem(IDC_BUTTON_SET_BLUETOOTH_HOOK)->SetWindowTextW(L"블루투스 후킹 시작");

}

void CtoolDlg::OnBnClickedButtonSetMtpHook()
{
	if (isMtphook)
		isMtphook = FALSE;
	else
		isMtphook = TRUE;

	bs1flt_.Bs1FltSetHook(BDC_MTP, isMtphook);

	if (isMtphook)
		GetDlgItem(IDC_BUTTON_SET_MTP_HOOK)->SetWindowTextW(L"MTP 후킹 해제");
	else
		GetDlgItem(IDC_BUTTON_SET_MTP_HOOK)->SetWindowTextW(L"MTP 후킹 시작");
}

void CtoolDlg::OnBnClickedButton3()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	CDlgProcessCreateRule dlg;

	dlg.DoModal();
}

void CtoolDlg::OnBnClickedButtonInit()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	DWORD state;

	state = bs1flt_.Bs1FltInit(s_wcurrent_path_.c_str(), Report, NULL);
	if (state)
	{
		MessageBoxW(L"Bs1fltControl 초기화 실패", L"Error", MB_ICONERROR);
		return;
	}

	CString debug;
	debug.Format(L"CDS Filter Driver Init State %s : %d", s_wcurrent_path_.c_str(), state);
	listLog_.AddString(debug);

	state = bs1flt_.Bs1FltSetPid(PG_PID_ALLOW, GetCurrentProcessId());
	if (state)
	{
		MessageBoxW(L"Bs1FltSetPid 실패", L"Error", MB_ICONERROR);
		return;
	}

	bs1flt_.Bs1FltSetPath(PG_PATH_BLACK, s_wcurrent_path_.c_str());
	if (state)
	{
		MessageBoxW(L"Bs1FltSetPath 실패", L"Error", MB_ICONERROR);
		return;
	}
	//bs1flt_.Bs1FltFolderProtectControl(TRUE);
	//SetProtectedFilePath(dir);
	bs1flt_.Bs1FltBegin(TRUE);
	if (state)
	{
		MessageBoxW(L"Bs1FltBegin 실패", L"Error", MB_ICONERROR);
		return;
	}
}

void CtoolDlg::OnBnClickedButtonOpen()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	DWORD state = bs1flt_.Bs1fltOpen();
	if (state != ERROR_SUCCESS)
	{
		CString debug;
		debug.Format(L"Bs1fltControl 열기 실패 : %d,  %p", state, bs1flt_.Bs1fltOpen);
		MessageBoxW(debug.GetBuffer(0), L"Error", MB_ICONERROR);
		return;
	}
	
	MessageBoxW(L"Bs1fltControl 열기 성공", L"Success", MB_ICONINFORMATION);
}

void CtoolDlg::OnBnClickedButtonFolderSetting()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	CFolderProtectDlg dlg;

	dlg.DoModal();
}

void CtoolDlg::OnBnClickedButtonRegditSetting()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	CDialogRegProtect dlg;
	dlg.DoModal();
}