using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using BLToolkit.Data.DataProvider;
using BLToolkit.DataAccess;
using BLToolkit.Data;
using BLToolkit.Mapping;
using BLToolkit.Reflection;
using BLToolkit.Reflection.Extension;

namespace AlbenikLibs.BLToolkit.Extensions
{
	public class SqlQueryEx : SqlQuery
	{
		#region Constructors

		public SqlQueryEx() { }

		public SqlQueryEx(DbManager dbManager) : base(dbManager) { }

		public SqlQueryEx(DbManager dbManager, bool dispose) : base(dbManager, dispose) { }

		public SqlQueryEx(ExtensionList extensions) { Extensions = extensions; }

		#endregion

		#region Protected methods

		#region Field list

		protected string[] GetFieldNames(DbManager db, Type type)
		{
			var om = db.MappingSchema.GetObjectMapper(type);
			var fields = GetFieldList(om);
			var list = new List<string>(fields.Length);

			foreach (var mm in GetFieldList(om))
			{
				list.Add((string)db.DataProvider.Convert(mm.Name, ConvertType.NameToQueryField));
			}

			return list.ToArray();
		}

		protected string CreateFieldListString(DbManager db, Type type, string tableAlias, IDictionary<string, string> aliases)
		{
			var fieldNameList = GetFieldNames(db, type);
			if (fieldNameList.Length < 1) return null;

			var tableAliasFormatString = (String.IsNullOrEmpty(tableAlias)) ? null : tableAlias + ".";

			var sb = new StringBuilder();
			foreach (var field in fieldNameList)
			{
				sb.AppendFormat("{0}[{1}]", tableAliasFormatString, field);
				if (aliases != null && aliases.ContainsKey(field) && !String.IsNullOrEmpty(aliases[field]))
				{
					sb.AppendFormat(" AS {0}", aliases[field]);
				}
			}
			sb.Remove(sb.Length - 2, 1);
			return sb.ToString();
		}

		protected string CreateFieldListString(DbManager db, Type type, string tableAlias)
		{
			return CreateFieldListString(db, type, tableAlias, null);
		}

		protected string CreateFieldListString(DbManager db, Type type)
		{
			return CreateFieldListString(db, type, null, null);
		}

		#endregion

		protected StringBuilder CreateBaseSelectText(DbManager db, Type type, ObjectMapper om)
		{
			var sb = new StringBuilder();
			sb.Append("SELECT\n");

			foreach (var mm in GetFieldList(om))
			{
				sb.AppendFormat("\t{0},\n", db.DataProvider.Convert(mm.Name, ConvertType.NameToQueryField));
			}

			var attr = (SelectFieldsAttribute)TypeHelper.GetFirstAttribute(type, typeof(SelectFieldsAttribute));
			foreach (var name in attr.FieldNames)
			{
				sb.AppendFormat("\t[{0}],\n", name);
			}

			sb.Remove(sb.Length - 2, 1);
			sb.AppendFormat("FROM\n\t{0}\n", db.DataProvider.Convert(GetTableName(type), ConvertType.NameToQueryTable));

			return sb;
		}

		//Actions
		protected new SqlQueryInfo CreateSelectByKeySqlText(DbManager db, Type type)
		{
			var om = db.MappingSchema.GetObjectMapper(type);
			var query = new SqlQueryInfo(om);

			var sb = CreateBaseSelectText(db, type, om);

			AddWherePK(db, query, sb);

			query.QueryText = sb.ToString();

			return query;
		}

		protected new SqlQueryInfo CreateSelectAllSqlText(DbManager db, Type type)
		{
			var om = db.MappingSchema.GetObjectMapper(type);
			var query = new SqlQueryInfo(om);

			query.QueryText = CreateBaseSelectText(db, type, om).ToString();

			return query;
		}

		protected SqlQueryInfo CreateSelectByFieldValueListSqlText(DbManager db, Type type)
		{
			var om = db.MappingSchema.GetObjectMapper(type);
			var query = new SqlQueryInfo(om);

			var sb = CreateBaseSelectText(db, type, om);

			sb.Append("WHERE {0} IN {1}");

			query.QueryText = sb.ToString();

			return query;
		}

		protected SqlQueryInfo CreateSelectByFieldValueSqlText(DbManager db, Type type)
		{
			var om = db.MappingSchema.GetObjectMapper(type);
			var query = new SqlQueryInfo(om);

			var sb = CreateBaseSelectText(db, type, om);

			sb.Append("WHERE {0} = @value");

			query.QueryText = sb.ToString();

			return query;
		}

		//Override
		protected override SqlQueryInfo CreateSqlText(DbManager db, Type type, string actionName)
		{
			switch (actionName)
			{
				case "SelectByFieldValueList":
					return CreateSelectByFieldValueListSqlText(db, type);
				case "SelectByFieldValue":
					return CreateSelectByFieldValueListSqlText(db, type);
				case "SelectAll":
					return CreateSelectAllSqlText(db, type);
				case "SelectByKey":
					return CreateSelectByKeySqlText(db, type);
				default:
					return base.CreateSqlText(db, type, actionName);
			}
		}

		#endregion

		#region GetBaseSelectText

		public StringBuilder GetBaseSelectText(DbManager db, Type type)
		{
			var om = db.MappingSchema.GetObjectMapper(type);
			return CreateBaseSelectText(db, type, om);
		}

		public StringBuilder GetBaseSelectText(Type type)
		{
			var db = GetDbManager();
			return GetBaseSelectText(db, type);
		}

		public StringBuilder GetBaseSelectText<T>(DbManager db)
		{
			return GetBaseSelectText(db, typeof(T));
		}

		public StringBuilder GetBaseSelectText<T>()
		{
			var db = GetDbManager();
			return GetBaseSelectText(db, typeof(T));
		}

		#endregion

		#region SelectByFieldValueList

		protected DbManager PrepareSelectByFieldValueList<KeyT>(DbManager db, Type type, string keyName, KeyT[] keyValues)
		{
			var query = GetSqlQueryInfo(db, type, "SelectByFieldValueList");

			var keysSb = new StringBuilder();
			foreach (var v in keyValues)
			{
				keysSb.Append(v);
				keysSb.Append(", ");
			}
			keysSb.Remove(keysSb.Length - 2, 2);

			var sql = String.Format(query.QueryText, keyName, keysSb);

			return db.SetCommand(sql);
		}

		//Select many
		public IList SelectManyByFieldValueList<KeyT>(DbManager db, Type type, string fieldName, KeyT[] fieldValues)
		{
			return PrepareSelectByFieldValueList(db, type, fieldName, fieldValues).ExecuteList(type);
		}

		public IList SelectManyByFieldValueList<KeyT>(Type type, string fieldName, KeyT[] fieldValues)
		{
			var db = GetDbManager();
			return SelectManyByFieldValueList(db, type, fieldName, fieldValues);
		}

		public List<T> SelectManyByFieldValueList<T, KeyT>(DbManager db, string fieldName, KeyT[] fieldValues)
		{
			return PrepareSelectByFieldValueList(db, typeof(T), fieldName, fieldValues).ExecuteList<T>();
		}

		public List<T> SelectManyByFieldValueList<T, KeyT>(string fieldName, KeyT[] fieldValues)
		{
			var db = GetDbManager();
			return SelectManyByFieldValueList<T, KeyT>(db, fieldName, fieldValues);
		}

		#endregion

		#region SelectByFieldValue

		protected DbManager PrepareSelectByFieldValue<KeyT>(DbManager db, Type type, string keyName, KeyT keyValue)
		{
			var query = GetSqlQueryInfo(db, type, "SelectByFieldValue");

			var sql = String.Format(query.QueryText, keyName);

			return db.SetCommand(sql, db.Parameter("@value", keyValue));
		}

		//Select one
		public object SelectOneByFieldValue<KeyT>(DbManager db, Type type, string fieldName, KeyT fieldValue)
		{
			return PrepareSelectByFieldValue(db, type, fieldName, fieldValue).ExecuteObject(type);
		}

		public object SelectOneByFieldValue<KeyT>(Type type, string fieldName, KeyT fieldValue)
		{
			var db = GetDbManager();
			return SelectOneByFieldValue(db, type, fieldName, fieldValue);
		}

		public T SelectOneByFieldValue<T, KeyT>(DbManager db, string fieldName, KeyT fieldValue)
		{
			return PrepareSelectByFieldValue(db, typeof(T), fieldName, fieldValue).ExecuteObject<T>();
		}

		public T SelectOneByFieldValue<T, KeyT>(string fieldName, KeyT fieldValue)
		{
			var db = GetDbManager();
			return SelectOneByFieldValue<T, KeyT>(db, fieldName, fieldValue);
		}

		//Select many
		public IList SelectManyByFieldValue<KeyT>(DbManager db, Type type, string fieldName, KeyT fieldValue)
		{
			return PrepareSelectByFieldValue(db, type, fieldName, fieldValue).ExecuteList(type);
		}

		public IList SelectManyByFieldValue<KeyT>(Type type, string fieldName, KeyT fieldValue)
		{
			var db = GetDbManager();
			return SelectManyByFieldValue(db, type, fieldName, fieldValue);
		}

		public List<T> SelectManyByFieldValue<T, KeyT>(DbManager db, string fieldName, KeyT fieldValue)
		{
			return PrepareSelectByFieldValue(db, typeof(T), fieldName, fieldValue).ExecuteList<T>();
		}

		public List<T> SelectManyByFieldValue<T, KeyT>(string fieldName, KeyT fieldValue)
		{
			var db = GetDbManager();
			return SelectManyByFieldValue<T, KeyT>(db, fieldName, fieldValue);
		}

		#endregion
	}
}