using System;
using System.Collections.Generic;
using Microsoft.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//using Dapper;

namespace bnhtrade.Core.Data.Database.Stock
{
    public class ReadSkuTransaction : Connection
    {
        private Data.Database.SqlWhereBuilder whereBuilder = new SqlWhereBuilder();
        private List<int> transactionIdList = new List<int>();

        public ReadSkuTransaction()
        {

        }

        /// <summary>
        /// Initialise result filters
        /// </summary>
        public void Init()
        {
            whereBuilder = new SqlWhereBuilder();
            IsReconciled = null;
            StockTransactionTypeName = null;
            StockTransactionTypeCode = null;
        }

        /// <summary>
        /// Read result filter
        /// </summary>
        public bool? IsReconciled { get; set; }

        /// <summary>
        /// Read result filter
        /// </summary>
        public List<string> StockTransactionTypeName { get; set; }

        /// <summary>
        /// Read result filter
        /// </summary>
        public List<string> StockTransactionTypeCode { get; set; }


        /// <summary>
        /// Retrive a 'Stock Journal ID' for a reconciled SKU transaction
        /// </summary>
        /// <param name="skuTransactionId">Stock SKU Transaction ID</param>
        /// <returns>Stock Journal ID</returns>
        public int? GetJournalId(int skuTransactionId)
        {
            using (var conn = new SqlConnection(SqlConnectionString))
            {
                conn.Open();

                using (var cmd = new SqlCommand(@"
                    SELECT StockJournalID FROM tblStockSkuTransaction WHERE StockSkuTransactionID=@transactionId
                    ", conn))
                {
                    cmd.Parameters.AddWithValue("@transactionId", skuTransactionId);

                    object obj = cmd.ExecuteScalar();

                    if (obj == null || obj == DBNull.Value)
                    {
                        return null;
                    }
                    else
                    {
                        return (int)obj;
                    }
                }
            }
        }

        /// <summary>
        /// Retrevies the IsProcessed for a given stock sku transaction
        /// </summary>
        /// <param name="skuTransactionId">the stock transaction id</param>
        /// <returns></returns>
        /// <exception cref="ArgumentException">Invalid stock transaction id</exception>
        public bool GetIsProcessed(int skuTransactionId) 
        {
            using (var conn = new SqlConnection(SqlConnectionString))
            {
                conn.Open();

                using (var cmd = new SqlCommand(@"
                    SELECT IsProcessed FROM tblStockSkuTransaction WHERE StockSkuTransactionID=@skuTransactionId
                    ", conn))
                {
                    cmd.Parameters.AddWithValue("@skuTransactionId", skuTransactionId);

                    object obj = cmd.ExecuteScalar();

                    if (obj == null || obj == DBNull.Value)
                    {
                        throw new ArgumentException("invalid stock transaction id");
                    }
                    else
                    {
                        return (bool)obj;
                    }
                }
            }
        }

        /// <summary>
        /// Populates model class from filtered database results
        /// </summary>
        /// <returns>List of SkuTransaction</returns>
        public List<Model.Stock.SkuTransaction> Read()
        {
            // order by stocktransId desc = Amazon reports are listed in datetime ASC order, some reports have date only, 
            // however I have reason to believe these are in time order.
            // Adding this means they at least get processed in the correct order (maybe)!

            var resultList = new List<Model.Stock.SkuTransaction>();
            //var parameters = new DynamicParameters();
            var parameterNew = new Dictionary<string, object>();

            string sql = @"
                SELECT tblStockSkuTransaction.StockSkuTransactionID AS SkuTransactionId
	                ,tblStockSkuTransaction.TransactionDate
	                ,tblStockSkuTransaction.ForeignKey
	                ,tblStockSkuTransaction.Reference
	                ,tblStockSkuTransaction.Detail
	                ,tblStockSkuTransaction.Quantity
                    ,tblStockSkuTransaction.IsProcessed
                    ,tblStockSkuTransaction.StockJournalID AS StockJournalId
	                ,tblStockSkuTransactionType.TypeCode AS SkuTransactionTypeCode
                    ,tblStockSkuTransactionType.TypeName AS SkuTransactionTypeName
	                ,tblSku.skuSkuNumber AS SkuNumber
	                ,tblStockSkuTransaction.RecordCreated
                FROM tblStockSkuTransaction
                INNER JOIN tblStockSkuTransactionType ON tblStockSkuTransaction.StockSkuTransactionTypeID = tblStockSkuTransactionType.StockSkuTransactionTypeID
                INNER JOIN tblSku ON tblStockSkuTransaction.SkuID = tblSku.skuSkuID 
                WHERE 1=1 ";

            if (transactionIdList.Any())
            {
                parameterNew.Add("@transactionIdList", this.transactionIdList);

                sql += @"
                    AND tblStockSkuTransaction.StockSkuTransactionID IN @transactionIdList ";
            }
            else
            {
                if (IsReconciled != null)
                {
                    sql += @"
                    AND tblStockSkuTransaction.IsProcessed =";
                    if (IsReconciled.GetValueOrDefault())
                    {
                        sql += " 1 ";
                    }
                    else
                    {
                        sql += " 0 ";
                    }
                }

                if (StockTransactionTypeName != null && StockTransactionTypeName.Any())
                {
                    parameterNew.Add("@stockTransactionTypeName", StockTransactionTypeName);

                    sql += @"
                    AND tblStockSkuTransactionType.TypeName IN @stockTransactionTypeName ";
                }

                if (StockTransactionTypeCode != null && StockTransactionTypeCode.Any())
                {
                    parameterNew.Add("@stockTransactionTypeCode", StockTransactionTypeCode);

                    sql += @"
                    AND tblStockSkuTransactionType.TypeCode IN @stockTransactionTypeCode ";
                }
            }

            sql += @"
                ORDER BY tblStockSkuTransaction.TransactionDate ASC, tblStockSkuTransaction.StockSkuTransactionID DESC;";

            using (SqlConnection conn = new SqlConnection(SqlConnectionString))
            {
                conn.Open();

                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    foreach (var param in parameterNew)
                    {
                        cmd.Parameters.AddWithValue(param.Key, param.Value);
                    }

                    using (SqlDataReader reader = cmd.ExecuteReader())
                    {
                        if (!reader.HasRows)
                        {
                            return resultList;
                        }
                        else
                        {
                            while (reader.Read())
                            {
                                int skuTransactionId = reader.GetInt32(0);

                                DateTime transactionDate = DateTime.SpecifyKind(reader.GetDateTime(1), DateTimeKind.Utc);

                                int? foreignKey = null;
                                if (!reader.IsDBNull(2)) { reader.GetInt32(2); }

                                string reference = null;
                                if (!reader.IsDBNull(3)) { reader.GetString(3); }

                                string detail = null;
                                if (!reader.IsDBNull(4)) { reader.GetString(4); }

                                int quantity = reader.GetInt32(5);

                                bool isProcessed = reader.GetBoolean(6);

                                int? stockJournalId = null;
                                if (!reader.IsDBNull(7)) { reader.GetInt32(7); }

                                string skuTransactionTypeCode = reader.GetString(8);

                                string skuTransactionTypeName = reader.GetString(9);

                                string skuNumber = reader.GetString(10);

                                DateTime recordCreated = DateTime.SpecifyKind(reader.GetDateTime(11), DateTimeKind.Utc);

                                var item = new Model.Stock.SkuTransaction(skuTransactionId, transactionDate, skuTransactionTypeCode, foreignKey, reference
                                    , detail, skuNumber, quantity, isProcessed, stockJournalId, recordCreated);
                                resultList.Add(item);
                            }
                        }
                    }
                }
            }
            return resultList;
        }

        /// <summary>
        /// Get Stock SKU Transaction by ID. Overrides any filters already set.
        /// </summary>
        /// <param name="transactionIdList"></param>
        /// <returns>List of SkuTransaction</returns>
        public List<Model.Stock.SkuTransaction> Read(List<int> transactionIdList)
        {
            var returnList = new List<Model.Stock.SkuTransaction>();
            if (!transactionIdList.Any())
            {
                return returnList;
            }
            this.transactionIdList = transactionIdList;
            returnList = Read();
            this.transactionIdList = new List<int>();
            return returnList;
        }
    }
}