// DlgDefectList.cpp : 구현 파일입니다.
//

#include "stdafx.h"
#include "ReviewSystem.h"
#include "DlgDefectList.h"
#include "MainFrm.h"
#include <algorithm>

using namespace CHReviewResult;

// SDC 향
#define DEFECTLISTCNT		13
TCHAR*	Defect_Titlelist[DEFECTLISTCNT]	= { _T("No"), _T("Mask_X(mm)"), _T("Mask_Y(mm)"), _T("Size"), _T("Peak"), _T("Cam"), _T("Scan"), _T("Type"), _T("Stack"), _T("Zone"), _T("Type"), _T("AOI_X(mm)"), _T("AOI_Y(mm)")};
int		Defect_width[DEFECTLISTCNT]		= {		  50,			  80,             80, 50,         50,        40,         40,         45,          45,         50,        50, 			  80,             80         };

// [2017:6:7]-[WEZASW] : BOE향
#define B7_DEFECTLISTCNT		13
TCHAR*	B7_Defect_Titlelist[B7_DEFECTLISTCNT]	= { _T("No"), _T("RV_X(mm)"), _T("RV_Y(mm)"), _T("DType"), _T("MType"),  _T("SType"), _T("DLength"), _T("Area"), _T("Peak"), _T("Cam"), _T("DType1"), _T("AOI_X(mm)"), _T("AOI_Y(mm)")};
int		B7_Defect_width[B7_DEFECTLISTCNT]		= {		40,			  75,				 75,		75,			75,				50,			60,				45,			45,			40,			60,				80,				80     };




// CDlgDefectList 대화 상자입니다.

IMPLEMENT_DYNAMIC(CDlgDefectList, CDialog)

CDlgDefectList::CDlgDefectList(CWnd* pParent /*=NULL*/)
	: CDialog(CDlgDefectList::IDD, pParent)
{
	m_pDDL2P = NULL;
	m_nProcessStatus = 0;
	m_bAsending = TRUE;
	m_pMapDefectResult = NULL;
}

CDlgDefectList::~CDlgDefectList()
{
}

void CDlgDefectList::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST_DEFECT, m_ctrlListDefect);
}


BEGIN_MESSAGE_MAP(CDlgDefectList, CDialog)
	ON_NOTIFY(LVN_GETDISPINFO, IDC_LIST_DEFECT, &CDlgDefectList::OnLvnGetdispinfoListDefect)
	ON_NOTIFY(LVN_COLUMNCLICK, IDC_LIST_DEFECT, &CDlgDefectList::OnLvnColumnclickListDefect)
	ON_NOTIFY(NM_DBLCLK, IDC_LIST_DEFECT, &CDlgDefectList::OnNMDblclkListDefect)
	ON_MESSAGE(UM_DEFECT_FILTER_UPDATE, &CDlgDefectList::OnDefectFilterUpdate)
	ON_MESSAGE(UM_PROCESS_STATUS_UPDATE, &CDlgDefectList::OnProcessStatusUpdate)

	ON_WM_SIZE()
	ON_WM_ERASEBKGND()
	ON_WM_CTLCOLOR()
END_MESSAGE_MAP()


// CDlgDefectList 메시지 처리기입니다.


BOOL CDlgDefectList::OnInitDialog()
{
	CDialog::OnInitDialog();

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

	return TRUE;  // return TRUE unless you set the focus to a control
	// 예외: OCX 속성 페이지는 FALSE를 반환해야 합니다.
}

BOOL CDlgDefectList::PreTranslateMessage(MSG* pMsg)
{
	// TODO: 여기에 특수화된 코드를 추가 및/또는 기본 클래스를 호출합니다.
	if( pMsg->message == WM_KEYDOWN )
	{
		if(pMsg->wParam == VK_RETURN || pMsg->wParam == VK_ESCAPE )
		{
			::TranslateMessage(pMsg);
			::DispatchMessage(pMsg);
			return TRUE;
		}
	}

	return CDialog::PreTranslateMessage(pMsg);
}

void CDlgDefectList::OnLvnGetdispinfoListDefect(NMHDR *pNMHDR, LRESULT *pResult)
{
	NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	CString strData, strText;
	SetData(strData, pDispInfo->item.iItem, pDispInfo->item.iSubItem);
	if((pDispInfo->item.mask & LVIF_TEXT) == LVIF_TEXT)
	{
	#ifdef UNICODE
		BSTR bstr;
		bstr = strData.AllocSysString();
		pDispInfo->item.pszText = (LPSTR)bstr;
		pDispInfo->item.pszText = static_cast<LPSTR>(bstr);
		SysFreeString(bstr);
	#endif
		//멀티바이트
		strcpy(pDispInfo->item.pszText, (LPSTR)(LPCTSTR)strData);
	}

	*pResult = 0;
}

void CDlgDefectList::OnLvnColumnclickListDefect(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	SortListDefect(pNMLV->iSubItem);
	*pResult = 0;
}

void CDlgDefectList::OnNMDblclkListDefect(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR);
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	int nPos = m_ctrlListDefect.GetSelectionMark();
	if (nPos >= 0)
	{
		CString strText;
		strText = m_ctrlListDefect.GetItemText(nPos, 0);
		int nDefectIdx = _ttoi(strText);
		if(nDefectIdx < 0)
			return;

		if(m_pDDL2P)
		{
			m_pDDL2P->DDL2P_SelectDefect(nDefectIdx);
		}
	}

	*pResult = 0;
}

void CDlgDefectList::SortListDefect(int nCol)
{
	LISTDefectit	it;
	CDefectResult*	pDefectResult;

	m_bAsending = !m_bAsending;

	if(nCol==3 || nCol==4 || nCol==5 || nCol==10)
	{
		vector< pair<CString,CDefectResult*> > vec;

		for(it = m_pSortDefect.begin(); it != m_pSortDefect.end(); ++it)
		{
			pDefectResult = *it;

			switch(nCol)
			{
			case 3:
				vec.push_back(make_pair(pDefectResult->strDefectType, pDefectResult));				
				break;
			case 4:
				vec.push_back(make_pair(pDefectResult->strMarkType, pDefectResult));				
				break;
			case 5:
				vec.push_back(make_pair(pDefectResult->strSizeType, pDefectResult));	
				break;
			case 10:
				vec.push_back(make_pair(pDefectResult->strDefectType1, pDefectResult));	
				break;
			default:
				continue;
			}
		}

		if(m_bAsending == TRUE)
		{
			std::sort(vec.begin(),vec.end(),greater< pair<CString,CDefectResult*> >());
		}
		else
		{
			std::sort(vec.begin(),vec.end(),less< pair<CString,CDefectResult*> >());
		}

		m_pSortDefect.clear();
		vector< pair<CString,CDefectResult*> >::iterator itVec;
		for(itVec = vec.begin(); itVec != vec.end(); ++itVec)
		{
			m_pSortDefect.push_back(itVec->second);			
		}

		vec.clear();
	}
	else
	{
		vector< pair<int, CDefectResult*> > vec;	
		int				nValue;		

		for(it = m_pSortDefect.begin(); it != m_pSortDefect.end(); ++it)
		{
			pDefectResult = *it;

			switch(nCol)
			{
			case 0: nValue = pDefectResult->nDefectIdx; break;			// _T("No")
			case 1: nValue = pDefectResult->nUMOriginX; break;			// _T("RV_X(mm)")
			case 2: nValue = pDefectResult->nUMOriginY; break;			// _T("RV_Y(mm)")
			case 6: nValue = pDefectResult->nAOISizeLength; break;		// _T("DLength")
			case 7: nValue = pDefectResult->nAOIArea; break;				// _T("Area")
			case 8: nValue = pDefectResult->nAOIPeak; break;				// _T("Peak")
			case 9: nValue = pDefectResult->nAOICameraIdx; break;		// _T("Cam")
			case 10: nValue = pDefectResult->nAOIScanIdx; break;		// _T("Cam")
			case 11: nValue = pDefectResult->dUMCenterOriginX; break;	// _T("AOI_X(mm)")
			case 12: nValue = pDefectResult->dUMCenterOriginY; break;	// _T("AOI_Y(mm)")
			default: continue;
			}

			vec.push_back(make_pair(nValue, pDefectResult));
		}

		if(m_bAsending == TRUE)
		{
			std::sort(vec.begin(),vec.end(),greater< pair<int,CDefectResult*> >());
		}
		else
		{
			std::sort(vec.begin(),vec.end(),less< pair<int,CDefectResult*> >());
		}

		m_pSortDefect.clear();
		vector< pair<int,CDefectResult*> >::iterator itVec;
		for(itVec = vec.begin(); itVec != vec.end(); ++itVec)
		{
			m_pSortDefect.push_back(itVec->second);			
		}

		vec.clear();
	}

	m_ctrlListDefect.SetItemCount((int)m_pSortDefect.size());
}

void CDlgDefectList::SetDefect()
{
	SetSortData();
}

void CDlgDefectList::SetListHeader(CString &strItem,int nRow,int nCol)
{
	if(nRow != 0)
		return;

	switch(nCol)
	{
	case 0: strItem = _T("No"); break;
	case 1: strItem = _T("RV_X(mm)"); break;
	case 2: strItem = _T("RV_Y(mm)"); break;
	case 3: strItem = _T("DType"); break;
	case 4: strItem = _T("Judge"); break;
	case 5: strItem = _T("SType"); break;
	case 6: strItem = _T("DLength"); break;
	case 7: strItem = _T("Area"); break;
	case 8: strItem = _T("Peak"); break;
	case 9: strItem = _T("Cam"); break;
	case 10: strItem = _T("ScanN"); break;
	case 11: strItem = _T("AOI_X(mm)"); break;
	case 12: strItem = _T("AOI_Y(mm)"); break;
	default: break;
	}
}

void CDlgDefectList::UpdateColumn()
{
	if(GetSafeHwnd() == NULL) return;

	m_ctrlListDefect.SetRedraw(FALSE);

	LV_COLUMN column;
	int col= B7_DEFECTLISTCNT;
	m_ctrlListDefect.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES);

	int i;
	for(i= 0; i< col; i++)
	{
		m_ctrlListDefect.DeleteColumn(0);
	}

	CString	strTitle;
	for(i= 0; i< col; i++)
	{
		column.mask= LVCF_FMT | LVCF_TEXT | LVCF_SUBITEM | LVCF_WIDTH;
		column.fmt= LVCFMT_LEFT;		
		SetListHeader(strTitle,0,i);		
		column.pszText = (LPSTR)(LPCTSTR)strTitle;
		column.iSubItem = i;
		column.cx= B7_Defect_width[i];
		m_ctrlListDefect.InsertColumn(i+1, &column);
	}

	m_ctrlListDefect.SetRedraw(TRUE);
}

void CDlgDefectList::SetData(CString& strItem,int nRow,int nCol)
{	
	if((int)m_pSortDefect.size() <= nRow || nRow < 0)
		return;

	CDefectResult* pDefectResult;
	pDefectResult = (CDefectResult*)m_pSortDefect.at(nRow);
	if(pDefectResult == NULL)
		return;

	strItem = _T("");

	switch(nCol)
	{
	case 0:		//No
		{
			strItem.Format(_T("%d"),pDefectResult->nDefectIdx);
		}
		break;
	case 1:		//RV_X(mm)
		{
			strItem.Format(_T("%.03lf"), pDefectResult->nUMOriginX / 1000.);
		}
		break;
	case 2:		//RV_Y(mm)
		{
			strItem.Format(_T("%.03lf"), pDefectResult->nUMOriginY / 1000.);
		}
		break;
	case 3:		//DType
		{
			strItem.Format(_T("%s"), pDefectResult->strDefectType);
		}
		break;
	case 4:		//MType
		{
			strItem.Format(_T("%s"), pDefectResult->strJudgeType);
		}
		break;
	case 5:		//S_Type
		{
			strItem.Format(_T("%s"), pDefectResult->strSizeType);
		}
		break;

	case 6:		//DLength
		{
			strItem.Format(_T("%d"), (int)pDefectResult->nAOISizeLength);
		}
		break;
	case 7:		//Area
		{
			strItem.Format(_T("%d"), (int)pDefectResult->nAOIArea);
		}
		break;
	case 8:		//Peak
		{
			strItem.Format(_T("%d"), pDefectResult->nAOIPeak);
		}
		break;
	case 9:		//Cam
		{
			strItem.Format(_T("%d"), pDefectResult->nAOICameraIdx);
		}
		break;
	case 10:	//D_Type1
		{
		//	strItem.Format(_T("%s"), pDefectResult->strDefectType1);
		strItem.Format(_T("%d"), pDefectResult->nAOIScanIdx);
		}
		break;
	case 11:	//AOI_X(mm)
		{
			strItem.Format(_T("%.03lf"), pDefectResult->dUMCenterOriginX / 1000.);
		}
		break;
	case 12:	//AOI_Y(mm)
		{
			strItem.Format(_T("%.03lf"), pDefectResult->dUMCenterOriginY / 1000.);
		}
		break;
	default: break;
	}
}

void CDlgDefectList::SetSortData()
{
	LISTDefectit	it;
	CDefectResult*	pDefectResult;

	m_pSortDefect.clear();
	for(it=m_pOrgDefect.begin();it!=m_pOrgDefect.end();it++)
	{
		pDefectResult = *it;
		if (!pDefectResult)
			continue;

		m_pSortDefect.push_back(pDefectResult);
	}

	m_ctrlListDefect.SetItemCount((int)m_pSortDefect.size());
}

void CDlgDefectList::SetDefect(MapDefectResult* pMapDefectResult, const SDefectFilter& mapOption)
{
	/*m_pOrgDefect.clear();
	m_pSortDefect.clear();

	UpdateColumn();

	if (!pMapDefectResult)
	{
		m_pMapDefectResult = NULL;		
	}
	else
	{
		m_pMapDefectResult = pMapDefectResult;

		CDefectResult* pDefectResult;
		for (MapDefectResultIt it = m_pMapDefectResult->begin(); it != m_pMapDefectResult->end(); it++)
		{
			pDefectResult = static_cast<CDefectResult*>(it->second);
			if (!pDefectResult)
				continue;

			// type
			if ( !mapOption.bTypeB && (pDefectResult->m_nDefectType==DEFECT_TYPE_NEGATIVE) )
			{
				continue;
			}

			if ( !mapOption.bTypeW && (pDefectResult->m_nDefectType==DEFECT_TYPE_POSITIVE) )
			{
				continue;
			}

			// size
			if (!mapOption.bSizeS && pDefectResult->m_nJudgeGrade==SIZE_SMALL)
			{
				continue;
			}

			if (!mapOption.bSizeM && pDefectResult->m_nJudgeGrade==SIZE_MIDDLE)
			{
				continue;
			}

			if (!mapOption.bSizeL && pDefectResult->m_nJudgeGrade==SIZE_LARGE)
			{
				continue;
			}

			if (!mapOption.bSizeO && pDefectResult->m_nJudgeGrade==SIZE_OVER)
			{
				continue;
			}

			// judge
			if (!mapOption.bJudgeOK && pDefectResult->m_nJudgeType==_e16Division_OK_Judge_)
			{
				continue;
			}

			if (!mapOption.bJudgeGR && pDefectResult->m_nJudgeType==_e16Division_GR_Judge_)
			{
				continue;
			}

			if (!mapOption.bJudgeNG && pDefectResult->m_nJudgeType==_e16Division_NG_Judge_)
			{
				continue;
			}

			m_pOrgDefect.push_back(pDefectResult);
			m_pSortDefect.push_back(pDefectResult);
		}		
	}

	m_bAsending = TRUE;
	SortListDefect(1);*/
}

void CDlgDefectList::UpdateSelectDefectList(int nDefectIdx)
{
	int i, nCount;
	CString strText;

	nCount = m_ctrlListDefect.GetItemCount();

	for(i = 0; i < nCount; i++)
	{
		strText = m_ctrlListDefect.GetItemText(i, 0);

		if(nDefectIdx == _ttoi(strText))
		{
			m_ctrlListDefect.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
			m_ctrlListDefect.EnsureVisible(i, FALSE);
			break;
		}
	}
}

void CDlgDefectList::UpdateDefectFilter(const SDefectFilter* pDefectFilter)
{
 	if (pDefectFilter==NULL) return;

	// save defect filter
	m_sDefectFilter = *pDefectFilter;

	this->PostMessage(UM_DEFECT_FILTER_UPDATE);
}

LRESULT	CDlgDefectList::OnProcessStatusUpdate(WPARAM wParam, LPARAM lParam)
{
	if(m_pMapDefectResult == NULL) return 0;

	if(m_pMapDefectResult->size() == 0) return 0;

	m_pOrgDefect.clear();
	m_pSortDefect.clear();

	UpdateColumn();

	CDefectResult* pDefectResult = NULL;
	for (constMapDefectResultIt it = m_pMapDefectResult->begin(); it != m_pMapDefectResult->end(); it++)
	{
		pDefectResult = static_cast<CDefectResult*>(it->second);

		if (!pDefectResult) continue;

		if (!m_sDefectFilter.bOpticDark && (pDefectResult->nOpticType == DEFECT_OPTIC_DARK) )
		{
			continue;
		}

		if (!m_sDefectFilter.bOpticBright && (pDefectResult->nOpticType == DEFECT_OPTIC_BRIGHT) )
		{
			continue;
		}

		if (!m_sDefectFilter.bOpticDkBr && (pDefectResult->nOpticType == DEFECT_OPTIC_DKBR) )
		{
			continue;
		}


		if (!m_sDefectFilter.bGrayBlack && (pDefectResult->nGrayType == DEFECT_GRAY_BLACK) )
		{
			continue;
		}

		if (!m_sDefectFilter.bGrayWhite && (pDefectResult->nGrayType == DEFECT_GRAY_WHITE) )
		{
			continue;
		}

		if (!m_sDefectFilter.bStackTD && (pDefectResult->nStackType == DEFECT_STACK_TD) )
		{
			continue;
		}

		if (!m_sDefectFilter.bStackCD && (pDefectResult->nStackType == DEFECT_STACK_CD) )
		{
			continue;
		}

		if (!m_sDefectFilter.bStackSD && (pDefectResult->nStackType == DEFECT_STACK_SD) )
		{
			continue;
		}

 		if (!m_sDefectFilter.bStackSP && (pDefectResult->nStackType == DEFECT_STACK_SP))
		{
 			continue;
 		} //taek

		m_pOrgDefect.push_back(pDefectResult);
		m_pSortDefect.push_back(pDefectResult);
	}

	m_bAsending = TRUE;

	SortListDefect(0);

	return 1;
}

LRESULT	CDlgDefectList::OnDefectFilterUpdate(WPARAM wParam, LPARAM lParam)
{
	if(m_pMapDefectResult == NULL) return 0;

	m_pOrgDefect.clear();
	m_pSortDefect.clear();

	UpdateColumn();

	CDefectResult* pDefectResult = NULL;
	for (constMapDefectResultIt it = m_pMapDefectResult->begin(); it != m_pMapDefectResult->end(); it++)
	{
		pDefectResult = static_cast<CDefectResult*>(it->second);

		if (!pDefectResult) continue;

		if (!m_sDefectFilter.bOpticDark && (pDefectResult->nOpticType == DEFECT_OPTIC_DARK) )
		{
			continue;
		}

		if (!m_sDefectFilter.bOpticBright && (pDefectResult->nOpticType == DEFECT_OPTIC_BRIGHT) )
		{
			continue;
		}

		if (!m_sDefectFilter.bOpticDkBr && (pDefectResult->nOpticType == DEFECT_OPTIC_DKBR) )
		{
			continue;
		}


		if (!m_sDefectFilter.bGrayBlack && (pDefectResult->nGrayType == DEFECT_GRAY_BLACK) )
		{
			continue;
		}

		if (!m_sDefectFilter.bGrayWhite && (pDefectResult->nGrayType == DEFECT_GRAY_WHITE) )
		{
			continue;
		}

		if (!m_sDefectFilter.bStackTD && (pDefectResult->nStackType == DEFECT_STACK_TD) )
		{
			continue;
		}

		if (!m_sDefectFilter.bStackPD && (pDefectResult->nStackType == DEFECT_STACK_PD) )
		{
			continue;
		}

		if (!m_sDefectFilter.bStackSD && (pDefectResult->nStackType == DEFECT_STACK_SD) )
		{
			continue;
		}

 		if (!m_sDefectFilter.bStackSP && (pDefectResult->nStackType == DEFECT_STACK_SP))
 		{
			continue;
		} //taek

		if (!m_sDefectFilter.bPositionFront && (pDefectResult->nDefectPos == DEFECT_POSITION_FRONT))
		{
			continue;
		}

		if (!m_sDefectFilter.bPositionBack && (pDefectResult->nDefectPos == DEFECT_POSITION_BACK))
		{
			continue;
		}

		m_pOrgDefect.push_back(pDefectResult);
		m_pSortDefect.push_back(pDefectResult);
	}

	m_bAsending = TRUE;

	SortListDefect(0);

	return 0;
}

void CDlgDefectList::UpdateProcessStatus(int nLineType, int nMachineType, int nProcessStatus, const CGlassResult* pGlassResult)
{
	if (pGlassResult==NULL) return;

	m_nProcessStatus = nProcessStatus;

	switch(m_nProcessStatus)
	{
	case ProcessLoading:
		break;
	case ProcessAlignStart:
		break;
	case ProcessReadRawFile:
	case ProcessReviewStart:
		m_pMapDefectResult = pGlassResult->GetMapDefectResult();
		this->SendMessage(UM_PROCESS_STATUS_UPDATE);
		g_pLog->DisplayMessage(_T("[DlgDefectList] Update Defect List!"));
		break;
	}

}


void CDlgDefectList::OnSize(UINT nType, int cx, int cy)
{
	__super::OnSize(nType, cx, cy);

	// TODO: 여기에 메시지 처리기 코드를 추가합니다.
	if (m_ctrlListDefect.GetSafeHwnd())
	{
		m_ctrlListDefect.SetWindowPos(NULL, 0, 0, cx, cy, SWP_NOZORDER);
	}
}

CDlgDefectList* CDlgDefectList::CDlgDefelist;
CDlgDefectList* CDlgDefectList::GetInstance(){ // CDlgDefecList 를 다른곳에서도 사용하게끔 싱글톤으로 구현 
	if(CDlgDefelist == NULL){
		CDlgDefelist = new CDlgDefectList;
	}

	return CDlgDefelist;
};

BOOL CDlgDefectList::OnEraseBkgnd(CDC* pDC)
{
	// TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
	CRect	rect;
	GetClientRect(&rect);
	__super::OnEraseBkgnd(pDC);
	pDC->FillSolidRect(rect, RGB(38,38,38) );

	return TRUE;
}


HBRUSH CDlgDefectList::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{

	HBRUSH hbr = __super::OnCtlColor(pDC, pWnd, nCtlColor);

	CRect rect;
	CString strClass = _T("");
	UINT nID = pWnd->GetDlgCtrlID();

	if(nCtlColor == CTLCOLOR_STATIC)
	{
		pDC->SetTextColor(RGB(255,255,255));
		pDC->SetBkColor(RGB(38,38,38));
		hbr = (HBRUSH)GetStockObject(NULL_BRUSH);
	}


	// TODO:  기본값이 적당하지 않으면 다른 브러시를 반환합니다.
	return hbr;
}