using System;
using System.Collections;

namespace System.Text.RegularExpressions.Syntax
{
	// Token: 0x020002E9 RID: 745
	internal class CharacterClass : Expression
	{
		// Token: 0x06001B03 RID: 6915 RVA: 0x000634C4 File Offset: 0x000616C4
		public CharacterClass(bool negate, bool ignore)
		{
			this.negate = negate;
			this.ignore = ignore;
			this.intervals = new IntervalCollection();
			int num = 144;
			this.pos_cats = new BitArray(num);
			this.neg_cats = new BitArray(num);
		}

		// Token: 0x06001B04 RID: 6916 RVA: 0x00063510 File Offset: 0x00061710
		public CharacterClass(Category cat, bool negate)
			: this(false, false)
		{
			this.AddCategory(cat, negate);
		}

		// Token: 0x1700083D RID: 2109
		// (get) Token: 0x06001B06 RID: 6918 RVA: 0x00063534 File Offset: 0x00061734
		// (set) Token: 0x06001B07 RID: 6919 RVA: 0x0006353C File Offset: 0x0006173C
		public bool Negate
		{
			get
			{
				return this.negate;
			}
			set
			{
				this.negate = value;
			}
		}

		// Token: 0x1700083E RID: 2110
		// (get) Token: 0x06001B08 RID: 6920 RVA: 0x00063548 File Offset: 0x00061748
		// (set) Token: 0x06001B09 RID: 6921 RVA: 0x00063550 File Offset: 0x00061750
		public bool IgnoreCase
		{
			get
			{
				return this.ignore;
			}
			set
			{
				this.ignore = value;
			}
		}

		// Token: 0x06001B0A RID: 6922 RVA: 0x0006355C File Offset: 0x0006175C
		public void AddCategory(Category cat, bool negate)
		{
			if (negate)
			{
				this.neg_cats[(int)cat] = true;
			}
			else
			{
				this.pos_cats[(int)cat] = true;
			}
		}

		// Token: 0x06001B0B RID: 6923 RVA: 0x00063590 File Offset: 0x00061790
		public void AddCharacter(char c)
		{
			this.AddRange(c, c);
		}

		// Token: 0x06001B0C RID: 6924 RVA: 0x0006359C File Offset: 0x0006179C
		public void AddRange(char lo, char hi)
		{
			Interval interval = new Interval((int)lo, (int)hi);
			if (this.ignore)
			{
				if (CharacterClass.upper_case_characters.Intersects(interval))
				{
					Interval interval2;
					if (interval.low < CharacterClass.upper_case_characters.low)
					{
						interval2 = new Interval(CharacterClass.upper_case_characters.low + 32, interval.high + 32);
						interval.high = CharacterClass.upper_case_characters.low - 1;
					}
					else
					{
						interval2 = new Interval(interval.low + 32, CharacterClass.upper_case_characters.high + 32);
						interval.low = CharacterClass.upper_case_characters.high + 1;
					}
					this.intervals.Add(interval2);
				}
				else if (CharacterClass.upper_case_characters.Contains(interval))
				{
					interval.high += 32;
					interval.low += 32;
				}
			}
			this.intervals.Add(interval);
		}

		// Token: 0x06001B0D RID: 6925 RVA: 0x00063698 File Offset: 0x00061898
		public override void Compile(ICompiler cmp, bool reverse)
		{
			IntervalCollection metaCollection = this.intervals.GetMetaCollection(new IntervalCollection.CostDelegate(CharacterClass.GetIntervalCost));
			int num = metaCollection.Count;
			for (int i = 0; i < this.pos_cats.Length; i++)
			{
				if (this.pos_cats[i] || this.neg_cats[i])
				{
					num++;
				}
			}
			if (num == 0)
			{
				return;
			}
			LinkRef linkRef = cmp.NewLink();
			if (num > 1)
			{
				cmp.EmitIn(linkRef);
			}
			foreach (object obj in metaCollection)
			{
				Interval interval = (Interval)obj;
				if (interval.IsDiscontiguous)
				{
					BitArray bitArray = new BitArray(interval.Size);
					foreach (object obj2 in this.intervals)
					{
						Interval interval2 = (Interval)obj2;
						if (interval.Contains(interval2))
						{
							for (int j = interval2.low; j <= interval2.high; j++)
							{
								bitArray[j - interval.low] = true;
							}
						}
					}
					cmp.EmitSet((char)interval.low, bitArray, this.negate, this.ignore, reverse);
				}
				else if (interval.IsSingleton)
				{
					cmp.EmitCharacter((char)interval.low, this.negate, this.ignore, reverse);
				}
				else
				{
					cmp.EmitRange((char)interval.low, (char)interval.high, this.negate, this.ignore, reverse);
				}
			}
			for (int k = 0; k < this.pos_cats.Length; k++)
			{
				if (this.pos_cats[k])
				{
					if (this.neg_cats[k])
					{
						cmp.EmitCategory(Category.AnySingleline, this.negate, reverse);
					}
					else
					{
						cmp.EmitCategory((Category)k, this.negate, reverse);
					}
				}
				else if (this.neg_cats[k])
				{
					cmp.EmitNotCategory((Category)k, this.negate, reverse);
				}
			}
			if (num > 1)
			{
				if (this.negate)
				{
					cmp.EmitTrue();
				}
				else
				{
					cmp.EmitFalse();
				}
				cmp.ResolveLink(linkRef);
			}
		}

		// Token: 0x06001B0E RID: 6926 RVA: 0x00063964 File Offset: 0x00061B64
		public override void GetWidth(out int min, out int max)
		{
			min = (max = 1);
		}

		// Token: 0x06001B0F RID: 6927 RVA: 0x0006397C File Offset: 0x00061B7C
		public override bool IsComplex()
		{
			return false;
		}

		// Token: 0x06001B10 RID: 6928 RVA: 0x00063980 File Offset: 0x00061B80
		private static double GetIntervalCost(Interval i)
		{
			if (i.IsDiscontiguous)
			{
				return (double)(3 + (i.Size + 15 >> 4));
			}
			if (i.IsSingleton)
			{
				return 2.0;
			}
			return 3.0;
		}

		// Token: 0x040015C4 RID: 5572
		private const int distance_between_upper_and_lower_case = 32;

		// Token: 0x040015C5 RID: 5573
		private static Interval upper_case_characters = new Interval(65, 90);

		// Token: 0x040015C6 RID: 5574
		private bool negate;

		// Token: 0x040015C7 RID: 5575
		private bool ignore;

		// Token: 0x040015C8 RID: 5576
		private BitArray pos_cats;

		// Token: 0x040015C9 RID: 5577
		private BitArray neg_cats;

		// Token: 0x040015CA RID: 5578
		private IntervalCollection intervals;
	}
}