// SOMView.cpp : implementation of the CSOMView class
//

#include "stdafx.h"
#include "SOM.h"

#include "SOMDoc.h"
#include "SOMView.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CSOMView

#define TIMER_ID 0x12345678
#define WEIGHT_NUM 25

IMPLEMENT_DYNCREATE(CSOMView, CView)

BEGIN_MESSAGE_MAP(CSOMView, CView)
	//{{AFX_MSG_MAP(CSOMView)
	ON_COMMAND(ID_BUTTON_NORM, OnButtonNorm)
	ON_UPDATE_COMMAND_UI(ID_BUTTON_NORM, OnUpdateButtonNorm)
	ON_COMMAND(ID_BUTTON_AVE, OnButtonAve)
	ON_UPDATE_COMMAND_UI(ID_BUTTON_AVE, OnUpdateButtonAve)
	ON_COMMAND(ID_BUTTON_W_RESET, OnButtonWReset)
	ON_WM_TIMER()
	ON_COMMAND(ID_BUTTON_CLEAR, OnButtonClear)
	ON_UPDATE_COMMAND_UI(ID_BUTTON_CLEAR, OnUpdateButtonClear)
	ON_COMMAND(ID_BUTTON_STOP, OnButtonStop)
	ON_UPDATE_COMMAND_UI(ID_BUTTON_STOP, OnUpdateButtonStop)
	ON_UPDATE_COMMAND_UI(ID_BUTTON_TRAIN, OnUpdateButtonTrain)
	ON_COMMAND(ID_BUTTON_TRAIN, OnButtonTrain)
	ON_UPDATE_COMMAND_UI(ID_BUTTON_W_RESET, OnUpdateButtonWReset)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CSOMView construction/destruction

CSOMView::CSOMView()
{
	// TODO: add construction code here
    m_pPointPainter = NULL;
    m_pWeightPainter = NULL;
    m_pBitMap = NULL;
    m_pMemDC = NULL;

    m_nState = STOPPED;
    m_nIndex = -1;
    m_nStep = 0;
}

CSOMView::~CSOMView()
{
    if (m_pPointPainter)
        delete m_pPointPainter;
    if (m_pWeightPainter)
        delete m_pWeightPainter;

    if (m_pBitMap)
    {
        m_pBitMap->DeleteObject();
        delete m_pBitMap;
    }

    if (m_pMemDC)
    {
        m_pMemDC->DeleteDC();
        delete m_pMemDC;
    }
}

BOOL CSOMView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CSOMView drawing
void CSOMView::DrawResult()
{
    CSOMDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
    ASSERT_VALID(m_pMemDC);

    static CPen penCorrdinate(PS_SOLID, 1, RGB(0, 0, 0));
    static CPen penLine(PS_SOLID, 1, RGB(200, 200, 200));
    static CPen penPoint1(PS_SOLID, 3, RGB(255, 0, 0));
    CBrush *pOldBrush;
    CPen *pOldPen;
    CRect rect;
    
    rect = m_pPointPainter->GetRect();
    rect.right = m_pWeightPainter->GetRect().right;

    pOldPen = m_pMemDC->GetCurrentPen();
    pOldBrush = m_pMemDC->GetCurrentBrush();

    int i;
    if (!m_pBitMap)
    {
        m_pBitMap = new CBitmap;
        m_pBitMap->CreateCompatibleBitmap(GetDC(), rect.Width(), rect.Height());
        m_pMemDC->SelectObject(&penCorrdinate);
        m_pMemDC->SelectObject(m_pBitMap);
        m_pPointPainter->DrawCoordinate(m_pMemDC);
        
        const VecPoint& vecPoint = pDoc->GetPatterns();
        if (!vecPoint.empty())
        {
            m_pMemDC->SelectObject(&penPoint1);
            for (i = 0; i <= vecPoint.size(); i++)
                m_pPointPainter->DrawPoint(m_pMemDC, &vecPoint[i]);    
        }
    }
    else
    {
        m_pMemDC->SelectObject(m_pBitMap);
    }


    m_pMemDC->SelectObject(&penCorrdinate);
    m_pWeightPainter->DrawCoordinate(m_pMemDC);
    
    int j;
    for (i = 0; i < WEIGHT_NUM; i++)
        for (j = 0; j < WEIGHT_NUM; j++)
        {
            CPointf &pf1 = pDoc->GetWeight(i, j);
            CPoint pl1;
            m_pWeightPainter->MPtoLP(&pf1, &pl1);

            m_pMemDC->SelectObject(&penLine);
            if (i != WEIGHT_NUM - 1)
            {
                CPointf &pf2 = pDoc->GetWeight(i + 1, j);
                CPoint pl2;
                m_pWeightPainter->MPtoLP(&pf2, &pl2);
                m_pMemDC->MoveTo(pl1);
                m_pMemDC->LineTo(pl2);
            }
            
            if (j != WEIGHT_NUM - 1)
            {
                CPointf &pf2 = pDoc->GetWeight(i, j + 1);
                CPoint pl2;
                m_pWeightPainter->MPtoLP(&pf2, &pl2);
                m_pMemDC->MoveTo(pl1);
                m_pMemDC->LineTo(pl2);
            }

            m_pMemDC->SelectObject(&penPoint1);
            m_pWeightPainter->DrawPoint(m_pMemDC, &pf1);
        }
    CRect rc;
    CString str;
    rc.left = rect.right - 90;
    rc.right = rect.right;
    rc.top = rect.bottom - 20;
    rc.bottom = rect.bottom;
    str.Format("step=%d", m_nStep);
    m_pMemDC->DrawText(str, &rc, DT_CENTER);

    m_pMemDC->SelectObject(pOldPen);
    m_pMemDC->SelectObject(pOldBrush);
}

void CSOMView::OnDraw(CDC* pDC)
{
    pDC->BitBlt(m_pPointPainter->GetRect().left, 
                m_pPointPainter->GetRect().top,
                m_pPointPainter->GetRect().Width() + m_pWeightPainter->GetRect().Width(),
                m_pPointPainter->GetRect().Height(),
                m_pMemDC, 0, 0, SRCCOPY);
}

/////////////////////////////////////////////////////////////////////////////
// CSOMView printing

BOOL CSOMView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CSOMView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CSOMView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CSOMView diagnostics

#ifdef _DEBUG
void CSOMView::AssertValid() const
{
	CView::AssertValid();
}

void CSOMView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CSOMDoc* CSOMView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CSOMDoc)));
	return (CSOMDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CSOMView message handlers
void CSOMView::Update()
{
    DrawResult();
    GetDocument()->UpdateAllViews(NULL);
}

void CSOMView::OnInitialUpdate() 
{
	CView::OnInitialUpdate();
	
	if (m_pPointPainter == NULL && m_pWeightPainter == NULL && m_pMemDC == NULL)
    {
        CRect rect;
	    GetClientRect(&rect);
        rect.right = rect.left + 300;
        rect.bottom = rect.top + 300;
        m_pPointPainter = new PainterFacade(rect, 150);
        rect.left = rect.right;
        rect.right = rect.right + 300;
        m_pWeightPainter = new PainterFacade(rect, 150);
        
        m_pMemDC = new CDC;
        
        m_pMemDC->CreateCompatibleDC(GetDC());
        
    }

    OnButtonWReset();
}

void CSOMView::OnButtonNorm() 
{
	CSOMDoc *pDoc = GetDocument();
    
    pDoc->AddNormalPatterns(1000, 0, 0.4, -1, 1);    
    if (m_pBitMap)
    {
        delete m_pBitMap;
        m_pBitMap = NULL;
    }
    m_nState = IDLE;

    Update();
}

void CSOMView::OnUpdateButtonNorm(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(m_nState != TRAIN);
}

void CSOMView::OnButtonAve() 
{
	CSOMDoc *pDoc = GetDocument();
    
    pDoc->AddAveragePatterns(1000, -1, 1);
    if (m_pBitMap)
    {
        delete m_pBitMap;
        m_pBitMap = NULL;
    }
    m_nState = IDLE;
    
    Update();
}

void CSOMView::OnUpdateButtonAve(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(m_nState != TRAIN);
}

void CSOMView::OnButtonTrain() 
{
	SetTimer(TIMER_ID, 42, NULL);

    m_nIndex = 0;
    m_nStep = 0;
    m_nState = TRAIN;
}

void CSOMView::OnUpdateButtonTrain(CCmdUI* pCmdUI) 
{
    pCmdUI->Enable(m_nState == IDLE);	
}

void CSOMView::OnButtonWReset() 
{
    if (m_nState == TRAIN)
    {
        KillTimer(TIMER_ID);
        m_nIndex = -1;
        m_nState = IDLE;
    }

    CSOMDoc *pDoc = GetDocument();
    pDoc->ResetWeights(WEIGHT_NUM, WEIGHT_NUM);
    Update();
}

void CSOMView::OnUpdateButtonWReset(CCmdUI* pCmdUI) 
{
    pCmdUI->Enable(TRUE);	
}

void CSOMView::OnButtonClear() 
{
	CSOMDoc *pDoc = GetDocument();
    
    pDoc->ClearPatterns();
    if (m_pBitMap)
    {
        delete m_pBitMap;
        m_pBitMap = NULL;
    }
    m_nState = STOPPED;

    Update();
}

void CSOMView::OnUpdateButtonClear(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(m_nState != TRAIN);
}

void CSOMView::OnTimer(UINT nIDEvent) 
{
	if (nIDEvent == TIMER_ID && m_nIndex != -1)
    {
	    CSOMDoc *pDoc = GetDocument();
        static int nonchange = 0;
        
        if (m_nIndex == 0)
            nonchange = 0;

        bool ret = pDoc->Train(m_nIndex, m_nStep);
        if (!ret)
        {
            nonchange++;
        }

        m_nIndex++;
        m_nStep++;
        if (m_nIndex == pDoc->GetPatterns().size())
        {
            if (nonchange == pDoc->GetPatterns().size())
            {
                KillTimer(TIMER_ID);
                m_nIndex = -1;
                m_nState = STOPPED;
            }
            else
            {
                m_nIndex = 0;
            }
        }

        Update();
    }
	
	CView::OnTimer(nIDEvent);
}

void CSOMView::OnButtonStop() 
{
    m_nState = IDLE;
    
    KillTimer(TIMER_ID);
    m_nIndex = -1;
}

void CSOMView::OnUpdateButtonStop(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(m_nState == TRAIN);
}