using System;
using System.Text;
using System.Text.RegularExpressions;
using CPF.ReoGrid.Core;

namespace CPF.ReoGrid
{
	[Serializable]
	public struct RangePosition : IRange, IRowRange, IColumnRange, ISheetAddress
	{
		public int Row
		{
			get
			{
				return this.row;
			}
			set
			{
				this.row = value;
			}
		}

		public int Col
		{
			get
			{
				return this.col;
			}
			set
			{
				this.col = value;
			}
		}

		public int Rows
		{
			get
			{
				return this.rows;
			}
			set
			{
				this.rows = value;
			}
		}

		public int Cols
		{
			get
			{
				return this.cols;
			}
			set
			{
				this.cols = value;
			}
		}

		public int EndRow
		{
			get
			{
				return this.row + this.rows - 1;
			}
			set
			{
				this.rows = value - this.row + 1;
			}
		}

		public int EndCol
		{
			get
			{
				return this.col + this.cols - 1;
			}
			set
			{
				this.cols = value - this.col + 1;
			}
		}

		public CellPosition StartPos
		{
			get
			{
				return new CellPosition(this.row, this.col, (byte)(this.positionProperties & 3));
			}
			set
			{
				this.row = value.Row;
				this.col = value.Col;
				this.StartRowProperty = value.RowProperty;
				this.StartColumnProperty = value.ColumnProperty;
			}
		}

		public CellPosition EndPos
		{
			get
			{
				return new CellPosition((this.rows == RangePosition.EntireRange.rows) ? 1048576 : this.EndRow, (this.cols == RangePosition.EntireRange.cols) ? 32768 : this.EndCol, (byte)((this.positionProperties & 12) >> 2));
			}
			set
			{
				this.EndRow = value.Row;
				this.EndCol = value.Col;
				this.EndRowProperty = value.RowProperty;
				this.EndColumnProperty = value.ColumnProperty;
			}
		}

		public PositionProperty StartRowProperty
		{
			get
			{
				return ((this.positionProperties & 1) == 1) ? PositionProperty.Absolute : PositionProperty.Relative;
			}
			set
			{
				bool flag = value == PositionProperty.Absolute;
				if (flag)
				{
					this.positionProperties |= 1;
				}
				else
				{
					this.positionProperties = (byte)((int)this.positionProperties & -2);
				}
			}
		}

		public PositionProperty StartColumnProperty
		{
			get
			{
				return ((this.positionProperties & 2) == 2) ? PositionProperty.Absolute : PositionProperty.Relative;
			}
			set
			{
				bool flag = value == PositionProperty.Absolute;
				if (flag)
				{
					this.positionProperties |= 2;
				}
				else
				{
					this.positionProperties = (byte)((int)this.positionProperties & -3);
				}
			}
		}

		public PositionProperty EndRowProperty
		{
			get
			{
				return ((this.positionProperties & 4) == 4) ? PositionProperty.Absolute : PositionProperty.Relative;
			}
			set
			{
				bool flag = value == PositionProperty.Absolute;
				if (flag)
				{
					this.positionProperties |= 4;
				}
				else
				{
					this.positionProperties = (byte)((int)this.positionProperties & -5);
				}
			}
		}

		public PositionProperty EndColumnProperty
		{
			get
			{
				return ((this.positionProperties & 8) == 8) ? PositionProperty.Absolute : PositionProperty.Relative;
			}
			set
			{
				bool flag = value == PositionProperty.Absolute;
				if (flag)
				{
					this.positionProperties |= 8;
				}
				else
				{
					this.positionProperties = (byte)((int)this.positionProperties & -9);
				}
			}
		}

		public RangePosition(CellPosition startPos, CellPosition endPos)
		{
			this.row = Math.Min(startPos.Row, endPos.Row);
			this.col = Math.Min(startPos.Col, endPos.Col);
			this.rows = Math.Max(startPos.Row, endPos.Row) - this.row + 1;
			this.cols = Math.Max(startPos.Col, endPos.Col) - this.col + 1;
			this.positionProperties = 0;
		}

		public RangePosition(CellPosition singlePos)
		{
			this.row = singlePos.Row;
			this.col = singlePos.Col;
			this.rows = 1;
			this.cols = 1;
			this.positionProperties = 0;
		}

		public RangePosition(int row, int col, int rows, int cols)
		{
			this.row = row;
			this.col = col;
			this.rows = rows;
			this.cols = cols;
			this.positionProperties = 0;
		}

		public RangePosition(string startCell, string endCell)
		{
			this = new RangePosition(new CellPosition(startCell), new CellPosition(endCell));
		}

		public RangePosition(string address)
		{
			this.positionProperties = 0;
			Match match = RGUtility.RangeReferenceRegex.Match(address);
			bool flag = !match.Success;
			if (flag)
			{
				match = RGUtility.SingleAbsoulteRangeRegex.Match(address);
			}
			bool flag2 = !match.Success && CellPosition.IsValidAddress(address);
			if (flag2)
			{
				CellPosition cellPosition = new CellPosition(address);
				this.row = cellPosition.Row;
				this.col = cellPosition.Col;
				this.rows = 1;
				this.cols = 1;
				this.StartRowProperty = cellPosition.RowProperty;
				this.StartColumnProperty = cellPosition.ColumnProperty;
				this.EndRowProperty = cellPosition.RowProperty;
				this.EndColumnProperty = cellPosition.ColumnProperty;
			}
			else
			{
				bool flag3 = !match.Success;
				if (flag3)
				{
					throw new ArgumentException("range is invalid: " + address);
				}
				int val = 0;
				int num = 0;
				int val2 = 0;
				int num2 = 0;
				bool flag4 = false;
				bool flag5 = false;
				bool success = match.Groups["from_row"].Success;
				if (success)
				{
					bool flag6 = !int.TryParse(match.Groups["from_row"].Value, out num);
					if (flag6)
					{
						throw new ArgumentException("range is invalid: " + address);
					}
					num--;
				}
				else
				{
					flag4 = true;
				}
				bool flag7 = !flag4 && match.Groups["to_row"].Success;
				if (flag7)
				{
					bool flag8 = !int.TryParse(match.Groups["to_row"].Value, out num2);
					if (flag8)
					{
						throw new ArgumentException("range is invalid: " + address);
					}
					num2--;
				}
				bool success2 = match.Groups["from_col"].Success;
				if (success2)
				{
					val = RGUtility.GetNumberOfChar(match.Groups["from_col"].Value);
				}
				else
				{
					flag5 = true;
				}
				bool flag9 = !flag5 && match.Groups["to_col"].Success;
				if (flag9)
				{
					val2 = RGUtility.GetNumberOfChar(match.Groups["to_col"].Value);
				}
				bool flag10 = flag5;
				if (flag10)
				{
					this.row = Math.Min(num, num2);
					this.rows = Math.Max(num, num2) - this.row + 1;
					this.col = 0;
					this.cols = -1;
				}
				else
				{
					bool flag11 = flag4;
					if (flag11)
					{
						this.row = 0;
						this.rows = -1;
						this.col = Math.Min(val, val2);
						this.cols = Math.Max(val, val2) - this.col + 1;
					}
					else
					{
						this.row = Math.Min(num, num2);
						this.col = Math.Min(val, val2);
						this.rows = Math.Max(num, num2) - this.row + 1;
						this.cols = Math.Max(val, val2) - this.col + 1;
					}
				}
				bool success3 = match.Groups["abs_from_row"].Success;
				if (success3)
				{
					this.positionProperties |= 1;
				}
				bool success4 = match.Groups["abs_from_col"].Success;
				if (success4)
				{
					this.positionProperties |= 2;
				}
				bool success5 = match.Groups["abs_to_row"].Success;
				if (success5)
				{
					this.positionProperties |= 4;
				}
				bool success6 = match.Groups["abs_to_col"].Success;
				if (success6)
				{
					this.positionProperties |= 8;
				}
			}
		}

		public override bool Equals(object obj)
		{
			bool flag = obj == null;
			bool result;
			if (flag)
			{
				result = false;
			}
			else
			{
				bool flag2 = !(obj is RangePosition);
				if (flag2)
				{
					result = false;
				}
				else
				{
					RangePosition rangePosition = this;
					RangePosition rangePosition2 = (RangePosition)obj;
					result = (rangePosition.row == rangePosition2.row && rangePosition.col == rangePosition2.col && rangePosition.rows == rangePosition2.rows && rangePosition.cols == rangePosition2.cols && rangePosition.positionProperties == rangePosition2.positionProperties);
				}
			}
			return result;
		}

		public static bool operator ==(RangePosition r1, RangePosition r2)
		{
			return r1.Equals(r2);
		}

		public static bool operator !=(RangePosition r1, RangePosition r2)
		{
			return !r1.Equals(r2);
		}

		public override int GetHashCode()
		{
			return this.row ^ this.col ^ this.rows ^ this.cols ^ (int)this.positionProperties;
		}

		public bool Contains(CellPosition pos)
		{
			return this.Contains(pos.Row, pos.Col);
		}

		public bool Contains(int row, int col)
		{
			return row >= this.row && col >= this.col && row <= this.EndRow && col <= this.EndCol;
		}

		public bool Contains(RangePosition range)
		{
			return this.row <= range.row && this.col <= range.col && this.EndRow >= range.EndRow && this.EndCol >= range.EndCol;
		}

		public bool ContainsRow(int row)
		{
			return row >= this.row && row <= this.EndRow;
		}

		public bool ContainsColumn(int col)
		{
			return col >= this.col && col <= this.EndCol;
		}

		public bool IntersectWith(RangePosition range)
		{
			int num = this.row + this.rows - 1;
			int num2 = this.col + this.cols - 1;
			return this.col + this.cols - 1 >= range.col && range.col + range.cols - 1 >= this.col && this.row + this.rows - 1 >= range.row && range.row + range.rows - 1 >= this.row;
		}

		public bool IsEmpty
		{
			get
			{
				return this.rows == 0 || this.cols == 0;
			}
		}

		public bool IsEntire
		{
			get
			{
				return this == RangePosition.EntireRange;
			}
		}

		public override string ToString()
		{
			return this.ToAddress();
		}

		public string ToAddress()
		{
			bool flag = this.rows <= -1 && this.cols <= -1;
			string result;
			if (flag)
			{
				StringBuilder stringBuilder = new StringBuilder();
				bool flag2 = this.StartRowProperty == PositionProperty.Absolute;
				if (flag2)
				{
					stringBuilder.Append('$');
				}
				stringBuilder.Append("1:");
				bool flag3 = this.EndRowProperty == PositionProperty.Absolute;
				if (flag3)
				{
					stringBuilder.Append('$');
				}
				stringBuilder.Append("1048576");
				result = stringBuilder.ToString();
			}
			else
			{
				bool flag4 = this.cols <= -1;
				if (flag4)
				{
					StringBuilder stringBuilder2 = new StringBuilder();
					bool flag5 = this.StartRowProperty == PositionProperty.Absolute;
					if (flag5)
					{
						stringBuilder2.Append('$');
					}
					stringBuilder2.Append(this.row + 1);
					stringBuilder2.Append(':');
					bool flag6 = this.EndRowProperty == PositionProperty.Absolute;
					if (flag6)
					{
						stringBuilder2.Append('$');
					}
					stringBuilder2.Append(this.EndRow + 1);
					result = stringBuilder2.ToString();
				}
				else
				{
					bool flag7 = this.rows <= -1;
					if (flag7)
					{
						StringBuilder stringBuilder3 = new StringBuilder();
						bool flag8 = this.StartColumnProperty == PositionProperty.Absolute;
						if (flag8)
						{
							stringBuilder3.Append('$');
						}
						stringBuilder3.Append(RGUtility.GetAlphaChar((long)this.col));
						stringBuilder3.Append(':');
						bool flag9 = this.EndColumnProperty == PositionProperty.Absolute;
						if (flag9)
						{
							stringBuilder3.Append('$');
						}
						stringBuilder3.Append(RGUtility.GetAlphaChar((long)this.EndCol));
						result = stringBuilder3.ToString();
					}
					else
					{
						StringBuilder stringBuilder4 = new StringBuilder();
						bool flag10 = this.StartColumnProperty == PositionProperty.Absolute;
						if (flag10)
						{
							stringBuilder4.Append('$');
						}
						stringBuilder4.Append(RGUtility.GetAlphaChar((long)this.col));
						bool flag11 = this.StartRowProperty == PositionProperty.Absolute;
						if (flag11)
						{
							stringBuilder4.Append('$');
						}
						stringBuilder4.Append(this.row + 1);
						stringBuilder4.Append(':');
						bool flag12 = this.EndColumnProperty == PositionProperty.Absolute;
						if (flag12)
						{
							stringBuilder4.Append('$');
						}
						stringBuilder4.Append(RGUtility.GetAlphaChar((long)this.EndCol));
						bool flag13 = this.EndRowProperty == PositionProperty.Absolute;
						if (flag13)
						{
							stringBuilder4.Append('$');
						}
						stringBuilder4.Append(this.EndRow + 1);
						result = stringBuilder4.ToString();
					}
				}
			}
			return result;
		}

		public string ToRelativeAddress()
		{
			bool flag = this.rows <= -1 && this.cols <= -1;
			string result;
			if (flag)
			{
				result = "1:1048576";
			}
			else
			{
				bool flag2 = this.cols <= -1;
				if (flag2)
				{
					result = string.Format("{0}:{1}", this.row + 1, this.EndRow + 1);
				}
				else
				{
					bool flag3 = this.rows <= -1;
					if (flag3)
					{
						result = string.Format("{0}:{1}", RGUtility.GetAlphaChar((long)this.col), RGUtility.GetAlphaChar((long)this.EndCol));
					}
					else
					{
						result = string.Format("{0}{1}:{2}{3}", new object[]
						{
							RGUtility.GetAlphaChar((long)this.col),
							this.row + 1,
							RGUtility.GetAlphaChar((long)this.EndCol),
							this.EndRow + 1
						});
					}
				}
			}
			return result;
		}

		public string ToAbsoluteAddress()
		{
			bool flag = this.rows <= -1 && this.cols <= -1;
			string result;
			if (flag)
			{
				result = "$1:$1048576";
			}
			else
			{
				bool flag2 = this.cols <= -1;
				if (flag2)
				{
					result = string.Format("${0}:${1}", this.row + 1, this.EndRow + 1);
				}
				else
				{
					bool flag3 = this.rows <= -1;
					if (flag3)
					{
						result = string.Format("${0}:${1}", RGUtility.GetAlphaChar((long)this.col), RGUtility.GetAlphaChar((long)this.EndCol));
					}
					else
					{
						result = string.Format("${0}${1}:${2}${3}", new object[]
						{
							RGUtility.GetAlphaChar((long)this.col),
							this.row + 1,
							RGUtility.GetAlphaChar((long)this.EndCol),
							this.EndRow + 1
						});
					}
				}
			}
			return result;
		}

		public string ToStringSpans()
		{
			return string.Format("{0}R x {1}C", this.rows, this.cols);
		}

		public void Offset(int rows, int cols)
		{
			this.row += rows;
			this.col += cols;
		}

		public static bool IsValidAddress(string address)
		{
			return RGUtility.RangeReferenceRegex.IsMatch(address) || RGUtility.CellReferenceRegex.IsMatch(address) || RGUtility.SingleAbsoulteRangeRegex.IsMatch(address);
		}

		public bool IsSingleCell
		{
			get
			{
				return this.rows == 1 && this.cols == 1;
			}
		}

		public static RangePosition FromCellPosition(CellPosition startPosition, CellPosition endPosition)
		{
			return RangePosition.FromCellPosition(startPosition.Row, startPosition.Col, endPosition.Row, endPosition.Col);
		}

		public static RangePosition FromCellPosition(int startRow, int startColumn, int endRow, int endColumn)
		{
			RangePosition rangePosition;
			rangePosition.row = Math.Min(startRow, endRow);
			rangePosition.col = Math.Min(startColumn, endColumn);
			rangePosition.rows = Math.Max(startRow, endRow) - rangePosition.row + 1;
			rangePosition.cols = Math.Max(startColumn, endColumn) - rangePosition.col + 1;
			rangePosition.positionProperties = 0;
			return rangePosition;
		}

		public static RangePosition Union(RangePosition range1, RangePosition range2)
		{
			bool flag = range1.IsEmpty && range2.IsEmpty;
			RangePosition result;
			if (flag)
			{
				result = RangePosition.Empty;
			}
			else
			{
				bool isEmpty = range1.IsEmpty;
				if (isEmpty)
				{
					result = range2;
				}
				else
				{
					bool isEmpty2 = range2.IsEmpty;
					if (isEmpty2)
					{
						result = range1;
					}
					else
					{
						int num = Math.Min(range1.row, range2.row);
						int num2 = Math.Min(range1.col, range2.col);
						int num3 = Math.Max(range1.EndRow, range2.EndRow);
						int num4 = Math.Max(range1.EndCol, range2.EndCol);
						result = new RangePosition(num, num2, num3 - num + 1, num4 - num2 + 1);
					}
				}
			}
			return result;
		}

		public void SetRows(int rows)
		{
			this.rows = rows;
		}

		public void SetCols(int cols)
		{
			this.cols = cols;
		}

		private int row;

		private int col;

		private int rows;

		private int cols;

		private byte positionProperties;

		public static readonly RangePosition Empty = new RangePosition(0, 0, 0, 0);

		public static readonly RangePosition EntireRange = new RangePosition(0, 0, -1, -1);
	}
}