MARKUS

using Dapper;

using Npgsql;

using NpgsqlTypes;

using System;

using System.Collections.Generic;

using System.Data;

using System.Linq;

namespace Markus.Service.DataBase

{

    internal class MixParameters : SqlMapper.IDynamicParameters, SqlMapper.IParameterLookup

    {

        public MixParameters(DBMSType dbms)

        {

            DBMS = dbms;

        }

        private DBMSType DBMS = DBMSType.MSSQL;

        internal const DbType EnumerableMultiParameter = (DbType)(-1);

        private static readonly Dictionary<SqlMapper.Identity, Action<IDbCommand, object>> paramReaderCache = new Dictionary<SqlMapper.Identity, Action<IDbCommand, object>>();

        private readonly Dictionary<string, ParamInfo> _parameters = new Dictionary<string, ParamInfo>();

        private List<object> templates;

        /// <summary>

        ///     All the names of the param in the bag, use Get to yank them out

        /// </summary>

        public IEnumerable<string> ParameterNames

        {

            get { return _parameters.Select(p => p.Key); }

        }

        public int ParameterCount

        {

            get { return _parameters.Count; }

        }

        object SqlMapper.IParameterLookup.this[string name] =>

             _parameters.TryGetValue(name, out ParamInfo param) ? param.Value : null;

        internal static bool ShouldSetDbType(DbType? dbType)

            => dbType.HasValue && dbType.GetValueOrDefault() != EnumerableMultiParameter;

        internal static bool ShouldSetDbType(DbType dbType)

            => dbType != EnumerableMultiParameter; // just in case called with non-nullable

        void SqlMapper.IDynamicParameters.AddParameters(IDbCommand command, SqlMapper.Identity identity)

        {

            if (templates != null)

                foreach (var template in templates)

                {

                    var newIdent = identity.ForDynamicParameters(template.GetType());

                    Action<IDbCommand, object> appender;

                    lock (paramReaderCache)

                    {

                        if (!paramReaderCache.TryGetValue(newIdent, out appender))

                        {

                            appender = SqlMapper.CreateParamInfoGenerator(newIdent, false, true);

                            paramReaderCache[newIdent] = appender;

                        }

                    }

                    appender(command, template);

                }

            switch (DBMS)

            {

                case DBMSType.POSTGRESQL:

                case DBMSType.MSSQL:

                    msSqlAddParamaters(command, identity);

                    break;

                //case DBMSType.POSTGRESQL:

                //    npgAddParamaters(command, identity);

                    //break;

                default:

                    break;

            }

        }

        private void msSqlAddParamaters(IDbCommand command, SqlMapper.Identity identity)

        {

            foreach (var param in _parameters.Values)

            {

                if (param.CameFromTemplate) continue;

                var dbType = param.DbType;

                var val = param.Value;

                string name = Clean(param.Name);

                var isCustomQueryParameter = val is SqlMapper.ICustomQueryParameter;

                SqlMapper.ITypeHandler handler = null;

                if (dbType == null && val != null && !isCustomQueryParameter)

                {

#pragma warning disable 618

                    dbType = SqlMapper.LookupDbType(val.GetType(), name, true, out handler);

#pragma warning disable 618

                }

                if (isCustomQueryParameter)

                {

                    ((SqlMapper.ICustomQueryParameter)val).AddParameter(command, name);

                }

                else if (dbType == EnumerableMultiParameter)

                {

#pragma warning disable 612, 618

                    SqlMapper.PackListParameters(command, name, val);

#pragma warning restore 612, 618

                }

                else

                {

                    bool add = !command.Parameters.Contains(name);

                    IDbDataParameter p;

                    if (add)

                    {

                        p = command.CreateParameter();

                        p.ParameterName = name;

                    }

                    else

                    {

                        p = (IDbDataParameter)command.Parameters[name];

                    }

                    p.Direction = param.ParameterDirection;

                    if (handler == null)

                    {

#pragma warning disable 0618

                        p.Value = SqlMapper.SanitizeParameterValue(val);

#pragma warning restore 0618

                        if (ShouldSetDbType(dbType) && p.DbType != dbType.GetValueOrDefault())

                        {

                            p.DbType = dbType.GetValueOrDefault();

                        }

                        var s = val as string;

                        if (s?.Length <= DbString.DefaultLength)

                        {

                            p.Size = DbString.DefaultLength;

                        }

                        if (param.Size != null) p.Size = param.Size.Value;

                        if (param.Precision != null) p.Precision = param.Precision.Value;

                        if (param.Scale != null) p.Scale = param.Scale.Value;

                    }

                    else

                    {

                        if (ShouldSetDbType(dbType)) p.DbType = dbType.GetValueOrDefault();

                        if (param.Size != null) p.Size = param.Size.Value;

                        if (param.Precision != null) p.Precision = param.Precision.Value;

                        if (param.Scale != null) p.Scale = param.Scale.Value;

                        handler.SetValue(p, val ?? DBNull.Value);

                    }

                    if (add)

                    {

                        command.Parameters.Add(p);

                    }

                    param.AttachedParam = p;

                }

            }

            // note: most non-privileged implementations would use: this.ReplaceLiterals(command);

            //if (literals.Count != 0) SqlMapper.ReplaceLiterals(this, command);

        }

        private void npgAddParamaters(IDbCommand command, SqlMapper.Identity identity)

        { 

            foreach (var param in _parameters.Values)

            {

                if (((NpgsqlCommand)command).Parameters.Contains(param.Name))

                {

                    ((NpgsqlCommand)command).Parameters.Remove(param.Name);

                }

                var p = ParamInfoToNpgParam(param);

                p.ParameterName = param.Name;

                command.Parameters.Add(p);

                param.AttachedParam = p;

            }

        }

        private NpgsqlParameter ParamInfoToNpgParam(ParamInfo param)

        {

            NpgsqlParameter p = new NpgsqlParameter();

            var val = param.Value;

            p.Value = val ?? DBNull.Value;

            p.Direction = param.ParameterDirection;

            if (param.Size != null) p.Size = param.Size.Value;

            if (param.NpgsqlType != null)

            {

                p.NpgsqlDbType = param.NpgsqlType.Value;

            }

            else if (param.Value != null)

            {

                var npgType = dbTypeConvert.GetNpgsqlDbType(param.Value.GetType()).Value;

                if (npgType == NpgsqlDbType.Text)

                {

                    //npgType = NpgsqlDbType.Varchar;

                }

                p.NpgsqlDbType = npgType;

            }

            else if (param.DbType != null)

            {

                var npgType = dbTypeConvert.GetNpgsqlDbType(param.DbType.Value).Value;

                if (npgType == NpgsqlDbType.Text)

                {

                    //npgType = NpgsqlDbType.Varchar;

                }

                p.NpgsqlDbType = npgType;

            }

            else

            {

                throw new Exception($"{param.Name} npgSQL type을 알 수 없습니다.");

            }

            return p;

        }

        private static string Clean(string name)

        {

            if (!string.IsNullOrEmpty(name))

            {

                switch (name[0])

                {

                    case '@':

                    case ':':

                    case '?':

                        return name.Substring(1);

                }

            }

            return name;

        }

        internal void Add(string name,object value = null,NpgsqlTypes.NpgsqlDbType? npgsqlDbType = null, DbType? dbType = null, ParameterDirection? direction = null, int? size = null)

        {

            if(DBMS == DBMSType.MSSQL)

            {

                switch (direction)

                {

                    case ParameterDirection.Output:

                    case ParameterDirection.InputOutput:

                        if(size == null)

                        {

                            size = 50;

                            //throw new Exception($"{name}는 MSSQL인 경우 direction이 {direction.ToString()}이므로 size를 지정하여야 합니다.");

                        }

                    break;

                    default:

                        break;

                }

            }

            _parameters[Clean(name)] = new ParamInfo

            {

                Name = name,

                Value = value,

                ParameterDirection = direction ?? ParameterDirection.Input,

                DbType = dbType,

                NpgsqlType = npgsqlDbType,

                Size = size

            };

        }

        internal T Get<T>(string name)

        {

            var val = _parameters[name].AttachedParam.Value;

            if (val == DBNull.Value)

            {

                if (default(T) != null)

                    throw new ApplicationException("Attempting to cast a DBNull to a non nullable type!");

                return default(T);

            }

            return (T)val;

        }

        public NpgsqlParameter Get(string name)

        {

            return ParamInfoToNpgParam(_parameters[name]);

        }

        private class ParamInfo

        {

            public string Name { get; set; }

            public object Value { get; set; }

            public ParameterDirection ParameterDirection { get; set; }

            public DbType? DbType { get; set; }

            public NpgsqlTypes.NpgsqlDbType? NpgsqlType { get; set; }

            public int? Size { get; set; }

            public IDbDataParameter AttachedParam { get; set; }

            internal Action<object, DynamicParameters> OutputCallback { get; set; }

            internal object OutputTarget { get; set; }

            internal bool CameFromTemplate { get; set; }

            public byte? Precision { get; set; }

            public byte? Scale { get; set; }

        }

    }

}