using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace MyForm.CustomCtrl
{
    //Grid control.
    public partial class GraphGrid : Control
    {
        public GraphGrid()
        {
            this.BackColor = Color.White;
            _rowHeaders = new RowHeaders(this);
            _columns = new List<GraphGridColumn>();
            _rows = new List<GraphGridRow>();
            //No row is selected in the beginning.
            this.CurrentRowIndex = -1;
            InitializeComponent();
            
        }        
        //row height
        public int RowHeight
        {
            get { return _rowHeight; }
            set { _rowHeight = value; }
        }
        //width of the square column which includes some colored square with a number.
        public int SquareColumnWidth
        {
            get { return _squareColumnWidth; }
            set { _squareColumnWidth = value; }
        }
        //width of the head column which inlcudes the head label.
        public int HeadColumnWidth
        {
            get { return _headColumnWidth; }
            set { _headColumnWidth = value; }
        }
        //width of colored square cell
        public int GraphCellWidth
        {
            get { return _graphCellWidth; }
            set { _graphCellWidth = value; }
        }
        //height of colored square cell
        public int GraphCellHeight
        {
            get { return _graphCellHeight; }
            set { _graphCellHeight = value; }
        }
        //width of the head label
        public int HeadLabelWidth
        {
            get { return _headLabelWidth; }
            set { _headLabelWidth = value; }
        }
        //height of the head label
        public int HeadLabelHeight
        {
            get { return _headLabelHeight; }
            set { _headLabelHeight = value; }
        }
        //row headers
        public RowHeaders RowHeaders
        {
            get { return _rowHeaders; }
        }
        //rows include empty row
        public List<GraphGridRow> Rows
        {
            get { return _rows; }
        }
        //columns
        public List<GraphGridColumn> Columns
        {
            get { return _columns; }
        }
        //index of the selected row
        public int CurrentRowIndex { set; get; }
        protected override void OnPaint(PaintEventArgs pe)
        {
            base.OnPaint(pe);
            if (this.CurrentRowIndex != -1)
            {
                //Paint the selected row background.
                Rectangle rect = new Rectangle();
                rect.X = 0;
                rect.Y = CurrentRowIndex * _rowHeight;
                rect.Width = this.ClientRectangle.Width;
                rect.Height = _rowHeight;
                pe.Graphics.FillRectangle(Brushes.LightCyan, rect);
            }
            //paint the colored square cells
            for (int rowIndex = 0; rowIndex < _rows.Count; rowIndex++)
            {
                GraphGridRow row = _rows[rowIndex];
                if (row.IsEmpty == false)
                {                    
                    for (int colIndex = 0; colIndex < _columns.Count; colIndex++)
                    {
                        if (this.Rows[rowIndex].Cells.ContainsKey(colIndex))
                            this.DrawCell(rowIndex, colIndex, pe);
                    }
                }
            }
            //Draw horizontal lines those connect two cells in the same row.
            foreach(GraphGridRow row in _rows)
            {
                if (row.IsEmpty == false)
                {
                    foreach (int key in row.Relations.Keys)
                    {
                        this.DrawHorizontalLine(key, row.Relations[key], row.Index, pe);
                    }
                }
            }
            //Draw vertical lines those connect two cells in the same column.
            foreach (GraphGridColumn col in _columns)
            {
                foreach (int key in col.Relations.Keys)
                {
                    this.DrawVerticalLine(key, col.Relations[key], col.Index, pe);
                }
            }
        }
        //The method to draw square number cells.
        private void DrawCell(int rowIndex, int colIndex, PaintEventArgs pe)
        {
            GraphGridCell cell = this.Rows[rowIndex].Cells[colIndex];
            Point loc = new Point();
            loc.X = _headColumnWidth + colIndex * _squareColumnWidth + (_squareColumnWidth - _graphCellWidth) / 2;
            loc.Y = rowIndex * _rowHeight + (_rowHeight - _graphCellHeight) / 2;
            Size size = new Size(_graphCellWidth, _graphCellHeight);
            Rectangle rect = new Rectangle(loc, size);
            using (Brush b = new SolidBrush(cell.Color))
            {
                pe.Graphics.FillRectangle(b, rect);
            }
            pe.Graphics.DrawRectangle(Pens.Black, rect);
            StringFormat format = new StringFormat();
            format.Alignment = StringAlignment.Center;
            format.LineAlignment = StringAlignment.Center;
            pe.Graphics.DrawString(cell.Value, this.Font, Brushes.Black, rect, format);
        }
        //The method to draw lines those connect two cells in the same row.
        private void DrawHorizontalLine(int leftColIndex, int rightColIndex, int rowIndex, PaintEventArgs pe)
        {
            if (leftColIndex > rightColIndex)
            {
                int tem = leftColIndex;
                leftColIndex = rightColIndex;
                rightColIndex = tem;
            }
            int xLeft = _headColumnWidth + leftColIndex * _squareColumnWidth + (_squareColumnWidth) / 2;
            int xRight = _headColumnWidth + rightColIndex * _squareColumnWidth + (_squareColumnWidth) / 2;
            int yBottom = rowIndex * _rowHeight + (_rowHeight - _graphCellHeight) / 2;
            int yTop = yBottom - HORIZONTAL_LINE_HEIGHT;
            Point p1 = new Point(xLeft, yBottom);
            Point p2 = new Point(xLeft, yTop);
            Point p3 = new Point(xRight, yTop);
            Point p4 = new Point(xRight, yBottom);
            pe.Graphics.DrawLine(Pens.Black,p1, p2);
            pe.Graphics.DrawLine(Pens.Black, p2, p3);
            pe.Graphics.DrawLine(Pens.Black, p3, p4);            
        }
        //The method to draw lines those connect two cells in the same column.
        private void DrawVerticalLine(int topRowIndex, int bottomRowIndex, int colIndex, PaintEventArgs pe)
        {
            if (topRowIndex > bottomRowIndex)
            {
                int tem = topRowIndex;
                topRowIndex = bottomRowIndex;
                bottomRowIndex = tem;
            }
            int x = _headColumnWidth + colIndex * _squareColumnWidth + (_squareColumnWidth) / 2;
            int yBottom = bottomRowIndex * _rowHeight + (_rowHeight - _graphCellHeight) / 2;
            int yTop = topRowIndex * _rowHeight + (_rowHeight - _graphCellHeight) / 2 + _graphCellHeight;
            Point p1 = new Point(x, yTop);
            Point p2 = new Point(x, yBottom);
            pe.Graphics.DrawLine(Pens.Black, p1, p2);
        }
        
        private int _rowHeight = 40;
        private int _squareColumnWidth = 40;
        private int _headColumnWidth = 110;

        private int _graphCellWidth = 30;
        private int _graphCellHeight = 30;
        private int _headLabelWidth = 100;
        private int _headLabelHeight = 30;

        private const int HORIZONTAL_LINE_HEIGHT = 5;

        private List<GraphGridRow> _rows = null;
        private List<GraphGridColumn> _columns = null;
        private RowHeaders _rowHeaders = null;
    }    
    public class RowHeaders
    {
        public RowHeaders(GraphGrid grid)
        {
            _grid = grid;
        }
        public Label this[int rowIndex]
        {
            get { return _rowheadLabels[rowIndex];}
        }
        //Insert one header label.
        public void SetLabel(int rowIndex, string text)
        {
            Label label = new Label();
            label.BackColor = SystemColors.Control;
            label.Location = new Point((_grid.HeadColumnWidth - _grid.HeadLabelWidth) / 2,
                rowIndex * _grid.RowHeight + (_grid.RowHeight - _grid.HeadLabelHeight) / 2);
            label.Size = new Size(_grid.HeadLabelWidth,_grid.HeadLabelHeight);
            label.Text = text;
            label.TextAlign = ContentAlignment.MiddleCenter;
            _rowheadLabels[rowIndex] = label;
            //Store row index in Tag which would be used in click event handler later
            label.Tag = rowIndex;
            //Handle click event to select one row.
            label.Click += new EventHandler(label_Click);
            _grid.Controls.Add(label);
        }

        void label_Click(object sender, EventArgs e)
        {
            int rowIndex = Convert.ToInt32((sender as Label).Tag);
            if (_grid.CurrentRowIndex != rowIndex)
            {
                //Recover the old selected label.
                if(_grid.CurrentRowIndex != -1)
                    _rowheadLabels[_grid.CurrentRowIndex].BackColor = SystemColors.Control;
                //Modify the selected row.
                _grid.CurrentRowIndex = Convert.ToInt32((sender as Label).Tag);
                //Set the new selected label.
                _rowheadLabels[_grid.CurrentRowIndex].BackColor = Color.LightBlue;
                //Refresh the row background.
                _grid.Invalidate();
            }
            
        }
        //A simple method to add a label.
        public void AddLabel(string text)
        {
            this.SetLabel(_rowheadLabels.Keys.Count, text);
        }
        private Dictionary<int,Label> _rowheadLabels = new Dictionary<int,Label>();
        private GraphGrid _grid = null;
    }
    //Grid column include the square cells. The head column is not of this type.
    public class GraphGridColumn
    {
        public GraphGridColumn(int index)
        {
            _index = index;
        }
        //Index of the column.
        public int Index { get { return _index; } }
        //Relations of the cells. One relation includes two cells.
        public Dictionary<int, int> Relations
        {
            get { return _relations; }
        }
        private Dictionary<int, int> _relations = new Dictionary<int, int>();
        private int _index;
    }
    //Grid row includes the cells and cell relations in this row.
    public class GraphGridRow
    {
        public GraphGridRow(int index)
        {
            _index = index;
        }
        public GraphGridRow(int index,GraphGrid grid)
        {
            _index = index;
            _grid = grid;
        }
        //Inser a cell to certain column.
        public void SetCell(int colIndex, string value, Color color)
        {
            this.Cells[colIndex] = new GraphGridCell(_grid, _index, colIndex, value, color);
        }
        //Add a cell to the next column.
        public void AddCell(string value, Color color)
        {
            this.SetCell(this.Cells.Keys.Count, value, color);
        }
        //The index of the row.
        public int Index { get { return _index; } }
        //If this row is blank.
        public bool IsEmpty { set; get; }
        //Cells
        public Dictionary<int,GraphGridCell> Cells { get { return _cells; } }
        //Relations between cells.
        //key: row index, value: column index.
        public Dictionary<int, int> Relations
        {
            get { return _relations; }
        }
        private Dictionary<int, int> _relations = new Dictionary<int,int>();
        private int _index;
        private Dictionary<int, GraphGridCell> _cells = new Dictionary<int, GraphGridCell>();
        private GraphGrid _grid;
    }
    //Grid cell, includes the color, value(a number).
    public class GraphGridCell
    {
        public GraphGridCell(GraphGrid grid, int rowIndex, int colIndex)
        {
            _grid = grid;
            _rowIndex = rowIndex;
            _colIndex = colIndex;
        }
        public GraphGridCell(GraphGrid grid, int rowIndex, int colIndex,string value,Color color)
        {
            _grid = grid;
            _rowIndex = rowIndex;
            _colIndex = colIndex;
            this.Value = value;
            this.Color = color;
        }
        public GraphGrid Grid { get { return _grid; } }
        public int RowIndex { get { return _rowIndex; } }
        public int ColumnIndex { get { return _colIndex; } }
        public Color Color { set; get; }
        //The number shows in the cell.
        public string Value { set; get; }

        private GraphGrid _grid;
        private int _rowIndex;
        private int _colIndex;
    }
}

    private void GraphGridForm_Load(object sender, EventArgs e)
    {
        //Add the columns.
        for(int i = 0; i < 3; i++)
            this.graphGrid1.Columns.Add(new GraphGridColumn(i));
        //Add the head label in the first row.
        this.graphGrid1.RowHeaders.AddLabel("row head 1");
        //Add the first row.
        GraphGridRow row = new GraphGridRow(0);
        row.IsEmpty = false;
        row.AddCell("100", Color.Red);
        this.graphGrid1.Rows.Add(row);

        //Add the head label in the second row.
        this.graphGrid1.RowHeaders.AddLabel("row head 2");
        //Add the second row.
        row = new GraphGridRow(1);
        row.IsEmpty = false;
        row.AddCell("110", Color.Red);
        row.AddCell("210", Color.LightBlue);
        //Add a relation between cell in column 0 and cell in column 1
        row.Relations[0] = 1;
        this.graphGrid1.Rows.Add(row);

        //Add an empty row.
        row = new GraphGridRow(2);
        row.IsEmpty = true;
        this.graphGrid1.Rows.Add(row);

        //Add the head label in the third row.
        this.graphGrid1.RowHeaders.SetLabel(3,"row head 3");
        row = new GraphGridRow(3);
        row.IsEmpty = false;
        row.AddCell("120", Color.Red);
        row.AddCell("220", Color.LightBlue);
        row.AddCell("320", Color.Green);
        //Add relations between cells in column 0,1,2
        row.Relations[0] = 1;
        row.Relations[1] = 2;
        this.graphGrid1.Rows.Add(row);

        //Add relation between cell(row 1) and cell(row 3) in column 1
        this.graphGrid1.Columns[1].Relations[1] = 3;
        //Add relation between cell(row 0) and cell(row 1) in column 0
        this.graphGrid1.Columns[0].Relations[0] = 1;

    }

label.MouseDown += new MouseEventHandler(lable_MouseDown);
label.MouseUp += new MouseEventHandler(lable_MouseUp);


void lable_MouseDown(object sender, MouseEventArgs e)
        {
            int rowIndex = Convert.ToInt32((sender as Label).Tag);
            _grid.LastRowIndex = _grid.CurrentRowIndex;
            if (_grid.CurrentRowIndex != rowIndex)
            {
                //Recover the old selected label.
                if (_grid.CurrentRowIndex != -1)
                {
                    _rowheadLabels[_grid.CurrentRowIndex].BackColor = SystemColors.Control;                    
                }
                //Modify the selected row.
                _grid.CurrentRowIndex = Convert.ToInt32((sender as Label).Tag);
                //Set the new selected label.                

                _rowheadLabels[_grid.CurrentRowIndex].BackColor = Color.LightBlue;
                
                //Refresh the row background.
                _grid.Invalidate();
            }
        }

void lable_MouseUp(object sender, MouseEventArgs e)
        {
            int rowIndex = Convert.ToInt32((sender as Label).Tag);
            if (_grid.CurrentRowIndex != rowIndex)
            {}
        }