#include "stdafx.h"
#include "map.h"
#include "Utils.h"
#include "measuring.h"
#include "GeometryHelper.h"
#include "ShapeEditor.h"
#include "ShapefileDrawing.h"
#include "AngleHelper.h"

// ***************************************************************
//		DrawDynamic()
// ***************************************************************
void CMapView::DrawDynamic(CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid, bool drawBackBuffer /*= false*/, float offsetX /*= 0.0f*/, float offsetY /*= 0.0f*/)
{
	HDC hdc = pdc->GetSafeHdc();
	Gdiplus::Graphics* g = Gdiplus::Graphics::FromHDC(hdc);
	g->TranslateTransform(offsetX, offsetY);

	Gdiplus::Graphics* gTemp = NULL;
	if (drawBackBuffer)
	{
		// creating a temp buffer, and passing content of main buffer to it;
		// so that all the resulting stuff can passed to screen in one take, without flickering
		gTemp = Gdiplus::Graphics::FromImage(_drawingBitmap);
		gTemp->SetSmoothingMode(Gdiplus::SmoothingMode::SmoothingModeAntiAlias);
		gTemp->DrawImage(_bufferBitmap, 0.0f, 0.0f);
	}
	else
	{
		// main buffer was already drawn, so we don't care about flickering (snapshot operation),
		// so can draw on the output canvas directly
		gTemp = g;
	}
	
	if (HasDrawingData(MeasuringData))
	{
		GetMeasuringBase()->DrawData(gTemp, true, DragNone);
	}
	
	DrawShapeEditor(gTemp, true);

	DrawMovingShapes(gTemp, rcBounds, true);

	DrawRotationCenter(gTemp);

	DrawZoombox(gTemp);

	DrawCoordinates(gTemp);

	DrawFocusRectangle(gTemp);

	if (drawBackBuffer)
	{
		// it's not snapshot so we are using temp buffer to avoid flickering;
		// let's pass it to the screen here;
		g->DrawImage(_drawingBitmap, 0.0f, 0.0f);
		delete gTemp;
	}

	g->ReleaseHDC(pdc->GetSafeHdc());
	delete g;
}

// ***************************************************************
//	DrawRotationCenter
// ***************************************************************
void CMapView::DrawRotationCenter(Gdiplus::Graphics* g)
{
	if (m_cursorMode != cmRotateShapes) return;
	Gdiplus::Pen pen(Gdiplus::Color::Red);
	double x, y;
	ProjToPixel(_dragging.RotateCenter.x, _dragging.RotateCenter.y, &x, &y);
	int size = 6;
	g->DrawLine(&pen, (int)x - size, (int)y, (int)x + size, (int)y);
	g->DrawLine(&pen, (int)x, (int)y - size, (int)x, (int)y + size);
}

// ***************************************************************
//	DrawMovingShapes
// ***************************************************************
void CMapView::DrawMovingShapes(Gdiplus::Graphics* g, const CRect& rect, bool dynamicBuffer)
{
	if (!HasDrawingData(MovingShapes)) return;

	// somewhat enlarge temp bitmap, to include portions currently outside the screen
	int sizeX = 2 * rect.Width();
	int sizeY = 2 * rect.Height();
	Gdiplus::REAL offsetX = (sizeX - rect.Width()) / 2.0f;
	Gdiplus::REAL offsetY = (sizeY - rect.Height()) / 2.0f;

	if (!_moveBitmap)
	{
		_moveBitmap = new Gdiplus::Bitmap(sizeX, sizeY);
		Gdiplus::Graphics* gBuffer = Gdiplus::Graphics::FromImage(_moveBitmap);
		gBuffer->TranslateTransform(offsetX, offsetY);
		gBuffer->Clear(Gdiplus::Color::Transparent);
		CCollisionList list;	
		CShapefileDrawer drawer(gBuffer, &_extents, _pixelPerProjectionX, _pixelPerProjectionY, &list, GetCurrentScale(), GetCurrentZoom(), false);
		drawer.Draw(rect, _dragging.Shapefile);
		// clean up
		delete gBuffer;
	}
	
	switch (_dragging.Operation)
	{
		case DragMoveShapes:
			g->DrawImage(_moveBitmap, _dragging.GetOffsetX() - offsetX, _dragging.GetOffsetY() - offsetY);
			break;	
		case DragRotateShapes:
			double angle = GetDraggingRotationAngle();
			double x, y;
			ProjToPixel(_dragging.RotateCenter.x, _dragging.RotateCenter.y, &x, &y);
			Gdiplus::Matrix m;
			g->GetTransform(&m);
			g->TranslateTransform((Gdiplus::REAL)(x), (Gdiplus::REAL)(y));
			g->RotateTransform((Gdiplus::REAL)angle);
			g->TranslateTransform((Gdiplus::REAL)(-x), (Gdiplus::REAL)(-y));
			g->DrawImage(_moveBitmap, -offsetX, -offsetY);
			g->SetTransform(&m);
			break;
	}
}

// ***************************************************************
//	DrawShapeEditor
// ***************************************************************
void CMapView::DrawShapeEditor( Gdiplus::Graphics* g, bool dynamicBuffer )
{
	tkDrawingDataAvailable data = dynamicBuffer ? ShapeDigitizing : ActShape;
	if (!HasDrawingData(data)) return;

	int offsetX = _dragging.Move.x - _dragging.Start.x;
	int offsetY = _dragging.Move.y - _dragging.Start.y;

	if (_dragging.Operation == DragMoveVertex) 
	{
		offsetX = 0;
		offsetY = 0;
	}
	_shapeEditor->Render(g, dynamicBuffer, _dragging.Operation, offsetX, offsetY);
}

// ****************************************************************
//		DrawZoombox()
// ****************************************************************
void CMapView::DrawZoombox(Gdiplus::Graphics* g)
{
	bool zooming = m_cursorMode == cmZoomIn && _dragging.Operation == DragZoombox;
	bool selection = m_cursorMode == cmSelection && _dragging.Operation == DragSelectionBox;

	bool drawZoombox =  _leftButtonDown && _dragging.Start != _dragging.Move && (zooming || selection);
	if (drawZoombox)
	{
		CRect r = _dragging.GetRectangle();
		Gdiplus::Rect rect(r.left, r.top, r.right - r.left, r.bottom - r.top);
		
		g->SetPixelOffsetMode(Gdiplus::PixelOffsetMode::PixelOffsetModeHighQuality);
		if (selection)
		{
			// TODO: can be customized
			Gdiplus::SolidBrush brush(Gdiplus::Color(100, 255, 255, 0));	// yellow
			Gdiplus::Pen pen(Gdiplus::Color(255, 255, 255, 0));
			g->FillRectangle(&brush, rect);
			g->DrawRectangle(&pen, rect);
		}
		else
		{
			switch(_zoomBoxStyle)
			{
				case zbsRubberBand:
					{
						Gdiplus::Pen pen(Gdiplus::Color(255, 0, 0, 0), 1.0f);
						pen.SetDashStyle(Gdiplus::DashStyle::DashStyleDot);
						g->DrawRectangle(&pen, rect);
					}
					break;
				case zbsGray:
					{
						Gdiplus::SolidBrush brush(Gdiplus::Color(100, 192, 192, 192));
						Gdiplus::Pen pen(Gdiplus::Color(255, 192, 192, 192));
						g->FillRectangle(&brush, rect);
						g->DrawRectangle(&pen, rect);
					}
					break;
				case zbsOrange:
					{
						Gdiplus::SolidBrush brush(Gdiplus::Color(65, 255, 165, 0));
						Gdiplus::Pen pen(Gdiplus::Color(255, 255, 165, 0));
						g->FillRectangle(&brush, rect);
						g->DrawRectangle(&pen, rect);
					}
					break;
				case zbsBlue:
					{
						Gdiplus::SolidBrush brush(Gdiplus::Color(100, 173, 216, 230));
						Gdiplus::Pen pen(Gdiplus::Color(255, 30, 144, 255));
						g->FillRectangle(&brush, rect);
						g->DrawRectangle(&pen, rect);
					}
					break;
				case zbsGrayInverted:
					{
						Gdiplus::Rect r1(r.left, 0, r.Width(), r.top);
						Gdiplus::Rect r2(0,0, r.left, _viewHeight);
						Gdiplus::Rect r3(r.left, r.bottom, r.Width(), _viewHeight - r.bottom);
						Gdiplus::Rect r4(r.right, 0, _viewWidth - r.right, _viewHeight);
						Gdiplus::SolidBrush brush(Gdiplus::Color(100, 192, 192, 192));
					
						g->FillRectangle(&brush, r1);
						g->FillRectangle(&brush, r2);
						g->FillRectangle(&brush, r3);
						g->FillRectangle(&brush, r4);

						Gdiplus::Pen pen(Gdiplus::Color(255, 192, 192, 192));
						g->DrawRectangle(&pen, rect);
					}
					break;
			}
		}
		Gdiplus::PixelOffsetMode pixelOffsetMode = g->GetPixelOffsetMode();
		g->SetPixelOffsetMode(pixelOffsetMode);
	}
}

// ****************************************************************
//		DrawCoordinates()
// ****************************************************************
void CMapView::DrawCoordinates(Gdiplus::Graphics* g) 
{
	if(HasDrawingData(tkDrawingDataAvailable::Coordinates)) 
	{
		POINT p;
		if (GetCursorPos(&p))
		{
			ScreenToClient(&p);
			double x = p.x, y = p.y;
			double prX, prY;
			PixelToProjection(x, y, prX, prY);

			bool canUseDegrees = _transformationMode == tmWgs84Complied;
			if (_transformationMode == tmDoTransformation && (_showCoordinates == cdmDegrees || _showCoordinates == cdmAuto))
			{
				IGeoProjection* p = GetMapToWgs84Transform();
				if (p) {
					VARIANT_BOOL vb;

					// in some cases transform can change values on failure
					// therefore we shall use temp variables to preserve them
					double tempX = prX;
					double tempY = prY;

					p->Transform(&tempX, &tempY, &vb);
					if (vb) 
					{
						canUseDegrees = true;
						prX = tempX;
						prY = tempY;
					}
				}
			}

			if (_showCoordinates == cdmDegrees && !canUseDegrees) {
				// can't display degrees
			}
			else {
				CStringW s;
				if (canUseDegrees) 
				{
					CStringW lat = AngleHelper::FormatAngle(prY, _showCoordinatesFormat, 3, false);
					CStringW lng = AngleHelper::FormatAngle(prX, _showCoordinatesFormat, 3, false);

					s.Format(L"%s: %s; %s: %s", (LPCWSTR)m_globalSettings.GetLocalizedString(tkLocalizedStrings::lsLatitude), (LPCWSTR)lat,
						(LPCWSTR)m_globalSettings.GetLocalizedString(tkLocalizedStrings::lsLongitude), (LPCWSTR)lng);
				}
				else
				{
					s.Format(L"x=%.2f; y=%.2f", prX, prY);
				}
				Gdiplus::PointF point(0.0f, 0.0f);
				Gdiplus::RectF rect;
				
				g->MeasureString(s, s.GetLength(), _fontCourier, point, Gdiplus::StringFormat::GenericDefault(), &rect);
				if (rect.Width + 15 < _viewWidth)		// control must be big enough to host the string
				{
                    // position the text
                    point.X = _viewWidth - rect.Width - 7.0f;
                    point.Y = 7.0f;
                    if (_showCoordinatesBackground)
                    {
					    // draw a white box behind the coordinates
					    const Gdiplus::Rect r(_viewWidth - static_cast<int>(rect.Width - 7.0f), 7, static_cast<int>(rect.Width), static_cast<int>(rect.Height));
					    g->FillRectangle(&GetMeasuringBase()->_whiteBrush, r);
                        // with white background, we don't need shadowed text
                        g->DrawString(s.GetString(), s.GetLength(), _fontCourier, point, &GetMeasuringBase()->_textBrush);
				    }
                    else
                    {
                        // default display, shadowed text
                        DrawStringWithShade(g, s, _fontCourier, point, &GetMeasuringBase()->_textBrush, &GetMeasuringBase()->_whiteBrush);
                    }
                }
			}
		}
	}
}

// ****************************************************************
//		DrawFocusRectangle()
// ****************************************************************
void CMapView::DrawFocusRectangle(Gdiplus::Graphics* g)
{
	VARIANT_BOOL vb;
	_focusRectangle->get_Visible(&vb);
	if (!vb) {
		return;
	}

	float lineWidth;
	byte transparency;
	OLE_COLOR color;
	double x, y, width, height;
	_focusRectangle->get_X(&x);
	_focusRectangle->get_Y(&y);
	_focusRectangle->get_Width(&width);
	_focusRectangle->get_Height(&height);
	
	_focusRectangle->get_Color(&color);
	_focusRectangle->get_FillTransparency(&transparency);

	_focusRectangle->get_LineWidth(&lineWidth);

	Gdiplus::Pen pen(Utility::OleColor2GdiPlus(color, 192), lineWidth);

	Gdiplus::SolidBrush brush(Utility::OleColor2GdiPlus(color, transparency));

	g->DrawRectangle(&pen, (int)x, (int)y, (int)width, (int)height);
	g->FillRectangle(&brush, (int)x, (int)y, (int)width, (int)height);
}