using System;
using System.Collections.Generic;
using UnityEngine;

[Serializable]
public class value_class
{
	public List<float> value;

	public List<Vector2> value_multi;

	public List<float> select_value;

	public List<bool> active;

	public List<Rect> rect;

	public List<string> text;

	public bool value_active;

	public float value_total;

	public int active_total;

	public AnimationCurve curve;

	public animation_curve_math_class animation_curve_math;

	public SliderMode_Enum mode;

	public value_class()
	{
		value = new List<float>();
		value_multi = new List<Vector2>();
		select_value = new List<float>();
		active = new List<bool>();
		rect = new List<Rect>();
		text = new List<string>();
		value_active = true;
		curve = new AnimationCurve();
		animation_curve_math = new animation_curve_math_class();
	}

	public virtual void calc_active_total()
	{
		active_total = 0;
		for (int i = 0; i < value.Count; i++)
		{
			if (active[i])
			{
				value_total += value[i];
				active_total++;
			}
		}
	}

	public virtual int calc_index(int index)
	{
		int num = 0;
		for (int i = 0; i < index; i++)
		{
			if (active[i])
			{
				num++;
			}
		}
		return num;
	}

	public virtual void set_values(int value_index)
	{
		if (mode == SliderMode_Enum.One)
		{
			calc_value();
		}
		else
		{
			set_value_multi(value_index);
		}
	}

	public virtual void Active(int index)
	{
	}

	public virtual float GetPreviousValue(int index)
	{
		float result = 0f;
		for (int num = index - 1; num >= 0; num--)
		{
			if (active[num])
			{
				result = value_multi[num].y;
				break;
			}
		}
		return result;
	}

	public virtual int GetPreviousIndex(int index)
	{
		int num = index - 1;
		int result;
		while (true)
		{
			if (num >= 0)
			{
				if (active[num])
				{
					result = num;
					break;
				}
				num--;
				continue;
			}
			result = -1;
			break;
		}
		return result;
	}

	public virtual float GetNextValue(int index)
	{
		float result = 0f;
		for (int i = index + 1; i < value.Count; i++)
		{
			if (active[i])
			{
				result = value_multi[i].x;
				break;
			}
		}
		return result;
	}

	public virtual int GetNextIndex(int index)
	{
		int num = index + 1;
		int result;
		while (true)
		{
			if (num < value.Count)
			{
				if (active[num])
				{
					result = num;
					break;
				}
				num++;
				continue;
			}
			result = value.Count;
			break;
		}
		return result;
	}

	public virtual void calc_value()
	{
		value_total = 0f;
		float num = 0f;
		int num2 = default(int);
		calc_active_total();
		Keyframe[] array = new Keyframe[active_total + 1];
		int num3 = default(int);
		num3 = 0;
		if (mode == SliderMode_Enum.One)
		{
			for (num2 = 0; num2 < value.Count; num2++)
			{
				if (active[num2])
				{
					array[num3].value = 1f / ((float)active_total * 1f) * (float)(num3 + 1);
					array[num3].time = num + value[num2] / value_total;
					select_value[num2] = (num * 2f + value[num2] / value_total) / 2f;
					text[num2] = "(" + num.ToString("F2") + "-" + array[num3].time.ToString("F2") + ")";
					num = array[num3].time;
					num3++;
				}
				else
				{
					text[num2] = "(- )";
				}
			}
		}
		else
		{
			for (num2 = 0; num2 < value.Count; num2++)
			{
				if (active[num2])
				{
					array[num3].value = 1f / ((float)active_total * 1f) * (float)(num3 + 1);
					array[num3].time = value_multi[num2].y / 100f;
					if (array[num3].time == num)
					{
						if (!(array[num3].time < 1f))
						{
							array[num3 - 1].time = array[num3 - 1].time - 0.01f;
						}
						else
						{
							array[num3].time = array[num3].time + 0.01f;
						}
					}
					text[num2] = "(" + num.ToString("F2") + "-" + array[num3].time.ToString("F2") + ")";
					num = array[num3].time;
					num3++;
				}
				else
				{
					text[num2] = "(- )";
				}
			}
		}
		curve = animation_curve_math.set_curve_linear(new AnimationCurve(array));
	}

	public virtual void set_value_multi(int index)
	{
		if (value.Count == 0)
		{
			return;
		}
		calc_active_total();
		if (!(value_multi[index].y >= value_multi[index].x))
		{
			value_multi[index] = new Vector2(value_multi[index].x, value_multi[index].x + 0.5f);
		}
		int num = default(int);
		int num2 = 0;
		for (num = 0; num < value.Count; num++)
		{
			if (!active[num] && num > 0)
			{
				num2++;
				continue;
			}
			if (num > index)
			{
				value_multi[num] = new Vector2(value_multi[num - 1 - num2].y, value_multi[num].y);
				if (!(value_multi[num].x <= value_multi[num].y))
				{
					value_multi[num] = new Vector2(value_multi[num].x, value_multi[num].x + 0.5f);
				}
			}
			num2 = 0;
		}
		num2 = 0;
		if (index > 0)
		{
			for (num = index - 1; num >= 0; num--)
			{
				if (!active[num])
				{
					num2++;
				}
				else
				{
					value_multi[num] = new Vector2(value_multi[num].x, value_multi[num + 1 + num2].x);
					if (!(value_multi[num].y >= value_multi[num].x))
					{
						value_multi[num] = new Vector2(value_multi[num].y - 0.5f, value_multi[num].y);
					}
					num2 = 0;
				}
			}
		}
		int num3 = 0;
		for (num = 0; num < value.Count; num++)
		{
			if (active[num])
			{
				if (num3 == 0)
				{
					value_multi[num] = new Vector2(0f, value_multi[num].y);
				}
				if (num3 == active_total - 1)
				{
					value_multi[num] = new Vector3(value_multi[num].x, 100f);
				}
				num3++;
			}
		}
		calc_value();
	}

	public virtual void reset_values()
	{
		if (mode == SliderMode_Enum.One)
		{
			for (int i = 0; i < value.Count; i++)
			{
				value[i] = 50f;
			}
		}
		else
		{
			reset_value_multi();
		}
		calc_value();
	}

	public virtual void reset_value_multi()
	{
		int num = 0;
		int num2 = 0;
		Vector2 vector = default(Vector2);
		calc_active_total();
		if (active_total == 0)
		{
			return;
		}
		for (int i = 0; i < value.Count; i++)
		{
			if (active[i])
			{
				if (num2 == 0)
				{
					vector.x = 0f;
				}
				else
				{
					vector.x = value_multi[i - 1 - num].y;
				}
				vector.y = vector.x + 100f / (float)active_total;
				if (num2 == active_total)
				{
					vector.y = 100f;
				}
				value_multi[i] = vector;
				num = 0;
				num2++;
			}
			else
			{
				num++;
			}
		}
	}

	public virtual void reset_single_value(int index)
	{
		if (mode == SliderMode_Enum.One)
		{
			value[index] = 50f;
			calc_value();
		}
		else if (active[index])
		{
			calc_active_total();
			int num = calc_index(index);
			value_multi[index] = new Vector2(1f / (float)active_total * (float)num * 100f, (1f / (float)active_total * (float)num + 1f / (float)active_total) * 100f);
			set_value_multi(index);
		}
	}

	public virtual void change_value_active(bool invert)
	{
		for (int i = 0; i < value.Count; i++)
		{
			if (!invert)
			{
				active[i] = value_active;
			}
			else
			{
				active[i] = !active[i];
			}
		}
		set_values(0);
	}

	public virtual void add_value(int index, float number)
	{
		value.Insert(index, number);
		if (index > 0)
		{
			value_multi.Insert(index, new Vector2(100f, 100f));
		}
		else
		{
			value_multi.Insert(index, new Vector2(0f, 100f));
		}
		rect.Insert(index, default(Rect));
		select_value.Insert(index, 0f);
		active.Insert(index, true);
		text.Insert(index, string.Empty);
		calc_value();
	}

	public virtual void erase_value(int index)
	{
		value.RemoveAt(index);
		rect.RemoveAt(index);
		value_multi.RemoveAt(index);
		select_value.RemoveAt(index);
		active.RemoveAt(index);
		text.RemoveAt(index);
		if (value.Count > 0)
		{
			set_values(0);
		}
	}

	public virtual void clear_value()
	{
		value.Clear();
		rect.Clear();
		value_multi.Clear();
		select_value.Clear();
		active.Clear();
		text.Clear();
	}

	public virtual void SyncValueMulti()
	{
		int num = value.Count - value_multi.Count;
		for (int i = 0; i < num; i++)
		{
			if (i > 0)
			{
				value_multi.Add(new Vector2(100f, 100f));
			}
			else
			{
				value_multi.Add(new Vector2(0f, 100f));
			}
			rect.Add(default(Rect));
		}
		if (num != 0)
		{
			reset_value_multi();
		}
	}

	public virtual void swap_value(int index1, int index2)
	{
		float num = value[index1];
		float num2 = select_value[index1];
		bool flag = active[index1];
		value[index1] = value[index2];
		select_value[index1] = select_value[index2];
		active[index1] = active[index2];
		value[index2] = num;
		select_value[index2] = num2;
		active[index2] = flag;
		calc_value();
	}
}