using Dapper;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Dapper.Contrib.Extensions
{
    /// <summary>
    ///     修改mysql新增数据时返回影响记录数
    /// </summary>
    public static partial class SqlMapperExtensions
    {
        /// <summary>
        ///     Returns a single entity by a single id from table "Ts" asynchronously using Task. T must be of interface type.
        ///     Id must be marked with [Key] attribute.
        ///     Created entity is tracked/intercepted for changes and used by the Update() extension.
        /// </summary>
        /// <typeparam name="T">Interface type to create and populate</typeparam>
        /// <param name="connection">Open SqlConnection</param>
        /// <param name="id">Id of the entity to get, must be marked with [Key] attribute</param>
        /// <param name="transaction">The transaction to run under, null (the default) if none</param>
        /// <param name="commandTimeout">Number of seconds before command execution timeout</param>
        /// <returns>Entity of T</returns>
        public static async Task<T> GetAsync<T>(this IDbConnection connection, dynamic id,
            IDbTransaction transaction = null, int? commandTimeout = null) where T : class
        {
            Type type = typeof(T);
            if (!GetQueries.TryGetValue(type.TypeHandle, out string sql))
            {
                PropertyInfo key = GetSingleKey<T>(nameof(GetAsync));
                string name = GetTableName(type);
                sql = $"SELECT * FROM {name} WHERE {key.Name} = @keyName";
                GetQueries[type.TypeHandle] = sql;
            }

            DynamicParameters dynParms = new DynamicParameters();
            dynParms.Add("@keyName", id);

            if (!type.IsInterface)
            {
                return (await connection.QueryAsync<T>(sql, dynParms, transaction, commandTimeout)
                    .ConfigureAwait(false)).FirstOrDefault();
            }

            IDictionary<string, object> res =
                (await connection.QueryAsync<dynamic>(sql, dynParms).ConfigureAwait(false)).FirstOrDefault() as
                IDictionary<string, object>;

            if (res == null)
            {
                return null;
            }

            T obj = ProxyGenerator.GetInterfaceProxy<T>();

            foreach (PropertyInfo property in TypePropertiesCache(type))
            {
                object val = res[property.Name];
                if (val == null)
                {
                    continue;
                }

                if (property.PropertyType.IsGenericType &&
                    property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
                {
                    Type genericType = Nullable.GetUnderlyingType(property.PropertyType);
                    if (genericType != null)
                    {
                        property.SetValue(obj, Convert.ChangeType(val, genericType), null);
                    }
                }
                else
                {
                    property.SetValue(obj, Convert.ChangeType(val, property.PropertyType), null);
                }
            }

            ((IProxy)obj).IsDirty = false; //reset change tracking and return

            return obj;
        }

        /// <summary>
        ///     Returns a list of entites from table "Ts".
        ///     Id of T must be marked with [Key] attribute.
        ///     Entities created from interfaces are tracked/intercepted for changes and used by the Update() extension
        ///     for optimal performance.
        /// </summary>
        /// <typeparam name="T">Interface or type to create and populate</typeparam>
        /// <param name="connection">Open SqlConnection</param>
        /// <param name="transaction">The transaction to run under, null (the default) if none</param>
        /// <param name="commandTimeout">Number of seconds before command execution timeout</param>
        /// <returns>Entity of T</returns>
        public static Task<IEnumerable<T>> GetAllAsync<T>(this IDbConnection connection,
            IDbTransaction transaction = null, int? commandTimeout = null) where T : class
        {
            Type type = typeof(T);
            Type cacheType = typeof(List<T>);

            if (!GetQueries.TryGetValue(cacheType.TypeHandle, out string sql))
            {
                GetSingleKey<T>(nameof(GetAll));
                string name = GetTableName(type);

                sql = "SELECT * FROM " + name;
                GetQueries[cacheType.TypeHandle] = sql;
            }

            if (!type.IsInterface)
            {
                return connection.QueryAsync<T>(sql, null, transaction, commandTimeout);
            }

            return GetAllAsyncImpl<T>(connection, transaction, commandTimeout, sql, type);
        }

        private static async Task<IEnumerable<T>> GetAllAsyncImpl<T>(IDbConnection connection,
            IDbTransaction transaction, int? commandTimeout, string sql, Type type) where T : class
        {
            IEnumerable<dynamic> result = await connection.QueryAsync(sql).ConfigureAwait(false);
            List<T> list = new List<T>();
            foreach (IDictionary<string, object> res in result)
            {
                T obj = ProxyGenerator.GetInterfaceProxy<T>();
                foreach (PropertyInfo property in TypePropertiesCache(type))
                {
                    object val = res[property.Name];
                    if (val == null)
                    {
                        continue;
                    }

                    if (property.PropertyType.IsGenericType &&
                        property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
                    {
                        Type genericType = Nullable.GetUnderlyingType(property.PropertyType);
                        if (genericType != null)
                        {
                            property.SetValue(obj, Convert.ChangeType(val, genericType), null);
                        }
                    }
                    else
                    {
                        property.SetValue(obj, Convert.ChangeType(val, property.PropertyType), null);
                    }
                }

                ((IProxy)obj).IsDirty = false; //reset change tracking and return
                list.Add(obj);
            }

            return list;
        }

        /// <summary>
        ///     Inserts an entity into table "Ts" asynchronously using Task and returns identity id.
        /// </summary>
        /// <typeparam name="T">The type being inserted.</typeparam>
        /// <param name="connection">Open SqlConnection</param>
        /// <param name="entityToInsert">Entity to insert</param>
        /// <param name="transaction">The transaction to run under, null (the default) if none</param>
        /// <param name="commandTimeout">Number of seconds before command execution timeout</param>
        /// <param name="sqlAdapter">The specific ISqlAdapter to use, auto-detected based on connection if null</param>
        /// <returns>Identity of inserted entity</returns>
        public static async Task<int> InsertAsync<T>(this IDbConnection connection, T entityToInsert,
            IDbTransaction transaction = null,
            int? commandTimeout = null, ISqlAdapter sqlAdapter = null) where T : class
        {
            Type type = typeof(T);
            sqlAdapter = sqlAdapter ?? GetFormatter(connection);

            bool isList = false;
            if (type.IsArray)
            {
                isList = true;
                type = type.GetElementType();
            }
            else if (type.IsGenericType)
            {
                TypeInfo typeInfo = type.GetTypeInfo();
                bool implementsGenericIEnumerableOrIsGenericIEnumerable =
                    typeInfo.ImplementedInterfaces.Any(ti =>
                        ti.IsGenericType && ti.GetGenericTypeDefinition() == typeof(IEnumerable<>)) ||
                    typeInfo.GetGenericTypeDefinition() == typeof(IEnumerable<>);

                if (implementsGenericIEnumerableOrIsGenericIEnumerable)
                {
                    isList = true;
                    type = type.GetGenericArguments()[0];
                }
            }

            string name = GetTableName(type);
            StringBuilder sbColumnList = new StringBuilder(null);
            List<PropertyInfo> allProperties = TypePropertiesCache(type);
            List<PropertyInfo> keyProperties = KeyPropertiesCache(type).ToList();
            List<PropertyInfo> computedProperties = ComputedPropertiesCache(type);
            List<PropertyInfo> allPropertiesExceptKeyAndComputed =
                allProperties.ToList(); //.Except(keyProperties.Union(computedProperties)).ToList();

            for (int i = 0; i < allPropertiesExceptKeyAndComputed.Count; i++)
            {
                PropertyInfo property = allPropertiesExceptKeyAndComputed[i];
                sqlAdapter.AppendColumnName(sbColumnList, property.Name);
                if (i < allPropertiesExceptKeyAndComputed.Count - 1)
                {
                    sbColumnList.Append(", ");
                }
            }

            StringBuilder sbParameterList = new StringBuilder(null);
            for (int i = 0; i < allPropertiesExceptKeyAndComputed.Count; i++)
            {
                PropertyInfo property = allPropertiesExceptKeyAndComputed[i];
                sbParameterList.AppendFormat("@{0}", property.Name);
                if (i < allPropertiesExceptKeyAndComputed.Count - 1)
                {
                    sbParameterList.Append(", ");
                }
            }

            int returnVal = 0;
            bool wasClosed = connection.State == ConnectionState.Closed;
            if (wasClosed)
            {
                connection.Open();
            }

            if (!isList) //single entity
            {
                returnVal = await sqlAdapter.InsertAsync(connection, transaction, commandTimeout, name,
                    sbColumnList.ToString(),
                    sbParameterList.ToString(), keyProperties, entityToInsert);
            }
            else
            {
                //insert list of entities
                string cmd = $"insert into {name} ({sbColumnList}) values ({sbParameterList})";
                returnVal = await connection.ExecuteAsync(cmd, entityToInsert, transaction, commandTimeout);
            }

            if (wasClosed)
            {
                connection.Close();
            }

            return returnVal;
        }

        /// <summary>
        ///     Inserts an entity into table "Ts" asynchronously using Task and returns identity id.
        /// </summary>
        /// <typeparam name="T">The type being inserted.</typeparam>
        /// <param name="connection">Open SqlConnection</param>
        /// <param name="entityToInsert">Entity to insert</param>
        /// <param name="transaction">The transaction to run under, null (the default) if none</param>
        /// <param name="commandTimeout">Number of seconds before command execution timeout</param>
        /// <param name="sqlAdapter">The specific ISqlAdapter to use, auto-detected based on connection if null</param>
        /// <returns>Identity of inserted entity</returns>
        public static async Task<long> InsertReturnPrimaryKeyAsync<T>(this IDbConnection connection, T entityToInsert,
            IDbTransaction transaction = null,
            int? commandTimeout = null, ISqlAdapter sqlAdapter = null) where T : class
        {
            Type type = typeof(T);
            sqlAdapter = sqlAdapter ?? GetFormatter(connection);
            if (type.IsArray)
            {
                type = type.GetElementType();
            }
            else if (type.IsGenericType)
            {
                TypeInfo typeInfo = type.GetTypeInfo();
                bool implementsGenericIEnumerableOrIsGenericIEnumerable =
                    typeInfo.ImplementedInterfaces.Any(ti =>
                        ti.IsGenericType && ti.GetGenericTypeDefinition() == typeof(IEnumerable<>)) ||
                    typeInfo.GetGenericTypeDefinition() == typeof(IEnumerable<>);

                if (implementsGenericIEnumerableOrIsGenericIEnumerable)
                {
                    type = type.GetGenericArguments()[0];
                }
            }

            string name = GetTableName(type);
            StringBuilder sbColumnList = new StringBuilder(null);
            List<PropertyInfo> allProperties = TypePropertiesCache(type);
            List<PropertyInfo> keyProperties = KeyPropertiesCache(type).ToList();
            List<PropertyInfo> computedProperties = ComputedPropertiesCache(type);
            List<PropertyInfo> allPropertiesExceptKeyAndComputed =
                allProperties.ToList(); //.Except(keyProperties.Union(computedProperties)).ToList();

            for (int i = 0; i < allPropertiesExceptKeyAndComputed.Count; i++)
            {
                PropertyInfo property = allPropertiesExceptKeyAndComputed[i];
                sqlAdapter.AppendColumnName(sbColumnList, property.Name);
                if (i < allPropertiesExceptKeyAndComputed.Count - 1)
                {
                    sbColumnList.Append(", ");
                }
            }

            StringBuilder sbParameterList = new StringBuilder(null);
            for (int i = 0; i < allPropertiesExceptKeyAndComputed.Count; i++)
            {
                PropertyInfo property = allPropertiesExceptKeyAndComputed[i];
                sbParameterList.AppendFormat("@{0}", property.Name);
                if (i < allPropertiesExceptKeyAndComputed.Count - 1)
                {
                    sbParameterList.Append(", ");
                }
            }

            long returnVal = 0;
            bool wasClosed = connection.State == ConnectionState.Closed;
            if (wasClosed)
            {
                connection.Open();
            }

            //if (!isList) //single entity
            //{
            //    returnVal = await sqlAdapter.(connection, transaction, commandTimeout, name,
            //        sbColumnList.ToString(),
            //        sbParameterList.ToString(), keyProperties, entityToInsert);
            //}
            //else
            //{
            //insert list of entities
            string cmd = $"insert into {name} ({sbColumnList}) values ({sbParameterList});SELECT LAST_INSERT_ID();";
            returnVal = await connection.ExecuteScalarAsync<long>(cmd, entityToInsert, transaction, commandTimeout);
            //  }

            if (wasClosed)
            {
                connection.Close();
            }

            return returnVal;
        }

        /// <summary>
        ///     Updates entity in table "Ts" asynchronously using Task, checks if the entity is modified if the entity is tracked
        ///     by the Get() extension.
        /// </summary>
        /// <typeparam name="T">Type to be updated</typeparam>
        /// <param name="connection">Open SqlConnection</param>
        /// <param name="entityToUpdate">Entity to be updated</param>
        /// <param name="transaction">The transaction to run under, null (the default) if none</param>
        /// <param name="commandTimeout">Number of seconds before command execution timeout</param>
        /// <returns>true if updated, false if not found or not modified (tracked entities)</returns>
        public static async Task<bool> UpdateAsync<T>(this IDbConnection connection, T entityToUpdate,
            IDbTransaction transaction = null, int? commandTimeout = null) where T : class
        {
            if (entityToUpdate is IProxy proxy && !proxy.IsDirty)
            {
                return false;
            }

            Type type = typeof(T);

            if (type.IsArray)
            {
                type = type.GetElementType();
            }
            else if (type.IsGenericType)
            {
                TypeInfo typeInfo = type.GetTypeInfo();
                bool implementsGenericIEnumerableOrIsGenericIEnumerable =
                    typeInfo.ImplementedInterfaces.Any(ti =>
                        ti.IsGenericType && ti.GetGenericTypeDefinition() == typeof(IEnumerable<>)) ||
                    typeInfo.GetGenericTypeDefinition() == typeof(IEnumerable<>);

                if (implementsGenericIEnumerableOrIsGenericIEnumerable)
                {
                    type = type.GetGenericArguments()[0];
                }
            }

            List<PropertyInfo> keyProperties = KeyPropertiesCache(type).ToList();
            List<PropertyInfo> explicitKeyProperties = ExplicitKeyPropertiesCache(type);
            if (keyProperties.Count == 0 && explicitKeyProperties.Count == 0)
            {
                throw new ArgumentException("Entity must have at least one [Key] or [ExplicitKey] property");
            }

            string name = GetTableName(type);

            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("update {0} set ", name);

            List<PropertyInfo> allProperties = TypePropertiesCache(type);
            keyProperties.AddRange(explicitKeyProperties);
            List<PropertyInfo> computedProperties = ComputedPropertiesCache(type);
            List<PropertyInfo> nonIdProps = allProperties.Except(keyProperties.Union(computedProperties)).ToList();

            ISqlAdapter adapter = GetFormatter(connection);

            for (int i = 0; i < nonIdProps.Count; i++)
            {
                PropertyInfo property = nonIdProps[i];
                adapter.AppendColumnNameEqualsValue(sb, property.Name);
                if (i < nonIdProps.Count - 1)
                {
                    sb.Append(", ");
                }
            }

            sb.Append(" where ");
            for (int i = 0; i < keyProperties.Count; i++)
            {
                PropertyInfo property = keyProperties[i];
                adapter.AppendColumnNameEqualsValue(sb, property.Name);
                if (i < keyProperties.Count - 1)
                {
                    sb.Append(" and ");
                }
            }

            int updated = await connection
                .ExecuteAsync(sb.ToString(), entityToUpdate, commandTimeout: commandTimeout, transaction: transaction)
                .ConfigureAwait(false);
            return updated > 0;
        }

        /// <summary>
        ///     Delete entity in table "Ts" asynchronously using Task.
        /// </summary>
        /// <typeparam name="T">Type of entity</typeparam>
        /// <param name="connection">Open SqlConnection</param>
        /// <param name="entityToDelete">Entity to delete</param>
        /// <param name="transaction">The transaction to run under, null (the default) if none</param>
        /// <param name="commandTimeout">Number of seconds before command execution timeout</param>
        /// <returns>true if deleted, false if not found</returns>
        public static async Task<bool> DeleteAsync<T>(this IDbConnection connection, T entityToDelete,
            IDbTransaction transaction = null, int? commandTimeout = null) where T : class
        {
            if (entityToDelete == null)
            {
                throw new ArgumentException("Cannot Delete null Object", nameof(entityToDelete));
            }

            Type type = typeof(T);

            if (type.IsArray)
            {
                type = type.GetElementType();
            }
            else if (type.IsGenericType)
            {
                TypeInfo typeInfo = type.GetTypeInfo();
                bool implementsGenericIEnumerableOrIsGenericIEnumerable =
                    typeInfo.ImplementedInterfaces.Any(ti =>
                        ti.IsGenericType && ti.GetGenericTypeDefinition() == typeof(IEnumerable<>)) ||
                    typeInfo.GetGenericTypeDefinition() == typeof(IEnumerable<>);

                if (implementsGenericIEnumerableOrIsGenericIEnumerable)
                {
                    type = type.GetGenericArguments()[0];
                }
            }

            List<PropertyInfo> keyProperties = KeyPropertiesCache(type);
            List<PropertyInfo> explicitKeyProperties = ExplicitKeyPropertiesCache(type);
            if (keyProperties.Count == 0 && explicitKeyProperties.Count == 0)
            {
                throw new ArgumentException("Entity must have at least one [Key] or [ExplicitKey] property");
            }

            string name = GetTableName(type);
            keyProperties.AddRange(explicitKeyProperties);

            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("DELETE FROM {0} WHERE ", name);

            ISqlAdapter adapter = GetFormatter(connection);

            for (int i = 0; i < keyProperties.Count; i++)
            {
                PropertyInfo property = keyProperties[i];
                adapter.AppendColumnNameEqualsValue(sb, property.Name);
                if (i < keyProperties.Count - 1)
                {
                    sb.Append(" AND ");
                }
            }

            int deleted = await connection.ExecuteAsync(sb.ToString(), entityToDelete, transaction, commandTimeout)
                .ConfigureAwait(false);
            return deleted > 0;
        }

        /// <summary>
        ///     Delete all entities in the table related to the type T asynchronously using Task.
        /// </summary>
        /// <typeparam name="T">Type of entity</typeparam>
        /// <param name="connection">Open SqlConnection</param>
        /// <param name="transaction">The transaction to run under, null (the default) if none</param>
        /// <param name="commandTimeout">Number of seconds before command execution timeout</param>
        /// <returns>true if deleted, false if none found</returns>
        public static async Task<bool> DeleteAllAsync<T>(this IDbConnection connection,
            IDbTransaction transaction = null, int? commandTimeout = null) where T : class
        {
            Type type = typeof(T);
            string statement = "DELETE FROM " + GetTableName(type);
            int deleted = await connection.ExecuteAsync(statement, null, transaction, commandTimeout)
                .ConfigureAwait(false);
            return deleted > 0;
        }
    }
}

public partial interface ISqlAdapter
{
    /// <summary>
    ///     Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
    /// </summary>
    /// <param name="connection">The connection to use.</param>
    /// <param name="transaction">The transaction to use.</param>
    /// <param name="commandTimeout">The command timeout to use.</param>
    /// <param name="tableName">The table to insert into.</param>
    /// <param name="columnList">The columns to set with this insert.</param>
    /// <param name="parameterList">The parameters to set for this insert.</param>
    /// <param name="keyProperties">The key columns in this table.</param>
    /// <param name="entityToInsert">The entity to insert.</param>
    /// <returns>The Id of the row created.</returns>
    Task<int> InsertAsync(IDbConnection connection, IDbTransaction transaction, int? commandTimeout, string tableName,
        string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties, object entityToInsert);
}

public partial class SqlServerAdapter
{
    /// <summary>
    ///     Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
    /// </summary>
    /// <param name="connection">The connection to use.</param>
    /// <param name="transaction">The transaction to use.</param>
    /// <param name="commandTimeout">The command timeout to use.</param>
    /// <param name="tableName">The table to insert into.</param>
    /// <param name="columnList">The columns to set with this insert.</param>
    /// <param name="parameterList">The parameters to set for this insert.</param>
    /// <param name="keyProperties">The key columns in this table.</param>
    /// <param name="entityToInsert">The entity to insert.</param>
    /// <returns>The Id of the row created.</returns>
    public async Task<int> InsertAsync(IDbConnection connection, IDbTransaction transaction, int? commandTimeout,
        string tableName, string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties,
        object entityToInsert)
    {
        string cmd = $"INSERT INTO {tableName} ({columnList}) values ({parameterList}); select @@ROWCOUNT  num";
        SqlMapper.GridReader multi = await connection.QueryMultipleAsync(cmd, entityToInsert, transaction, commandTimeout)
            .ConfigureAwait(false);

        dynamic first = multi.Read().FirstOrDefault();
        if (first == null || first.num == null)
        {
            return 0;
        }

        int num = (int)first.num;

        return num;
    }
}

public partial class SqlCeServerAdapter
{
    /// <summary>
    ///     Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
    /// </summary>
    /// <param name="connection">The connection to use.</param>
    /// <param name="transaction">The transaction to use.</param>
    /// <param name="commandTimeout">The command timeout to use.</param>
    /// <param name="tableName">The table to insert into.</param>
    /// <param name="columnList">The columns to set with this insert.</param>
    /// <param name="parameterList">The parameters to set for this insert.</param>
    /// <param name="keyProperties">The key columns in this table.</param>
    /// <param name="entityToInsert">The entity to insert.</param>
    /// <returns>The Id of the row created.</returns>
    public async Task<int> InsertAsync(IDbConnection connection, IDbTransaction transaction, int? commandTimeout,
        string tableName, string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties,
        object entityToInsert)
    {
        string cmd = $"INSERT INTO {tableName} ({columnList}) values ({parameterList}); select @@ROWCOUNT  num";
        SqlMapper.GridReader multi = await connection.QueryMultipleAsync(cmd, entityToInsert, transaction, commandTimeout)
            .ConfigureAwait(false);

        dynamic first = multi.Read().FirstOrDefault();
        if (first == null || first.num == null)
        {
            return 0;
        }

        int num = (int)first.num;

        return num;
    }
}

public partial class MySqlAdapter
{
    /// <summary>
    ///     Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
    /// </summary>
    /// <param name="connection">The connection to use.</param>
    /// <param name="transaction">The transaction to use.</param>
    /// <param name="commandTimeout">The command timeout to use.</param>
    /// <param name="tableName">The table to insert into.</param>
    /// <param name="columnList">The columns to set with this insert.</param>
    /// <param name="parameterList">The parameters to set for this insert.</param>
    /// <param name="keyProperties">The key columns in this table.</param>
    /// <param name="entityToInsert">The entity to insert.</param>
    /// <returns>The Id of the row created.</returns>
    public async Task<int> InsertAsync(IDbConnection connection, IDbTransaction transaction, int? commandTimeout,
        string tableName,
        string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties, object entityToInsert)
    {
        string cmd = $"INSERT INTO {tableName} ({columnList}) VALUES ({parameterList});select ROW_COUNT() num";
        SqlMapper.GridReader multi = await connection.QueryMultipleAsync(cmd, entityToInsert, transaction, commandTimeout)
            .ConfigureAwait(false);

        dynamic first = multi.Read().FirstOrDefault();
        if (first == null || first.num == null)
        {
            return 0;
        }

        int num = (int)first.num;

        return num;
        //await connection.ExecuteAsync(cmd, entityToInsert, transaction, commandTimeout).ConfigureAwait(false);
        //var r = await connection.QueryAsync<dynamic>("SELECT LAST_INSERT_ID() id", transaction: transaction, commandTimeout: commandTimeout).ConfigureAwait(false);

        //var id = r.First().id;
        //if (id == null) return 0;
        //var pi = keyProperties as PropertyInfo[] ?? keyProperties.ToArray();
        //if (pi.Length == 0) return Convert.ToInt32(id);

        //var idp = pi[0];
        //idp.SetValue(entityToInsert, Convert.ChangeType(id, idp.PropertyType), null);

        //return Convert.ToInt32(id);
    }
}

public partial class PostgresAdapter
{
    /// <summary>
    ///     Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
    /// </summary>
    /// <param name="connection">The connection to use.</param>
    /// <param name="transaction">The transaction to use.</param>
    /// <param name="commandTimeout">The command timeout to use.</param>
    /// <param name="tableName">The table to insert into.</param>
    /// <param name="columnList">The columns to set with this insert.</param>
    /// <param name="parameterList">The parameters to set for this insert.</param>
    /// <param name="keyProperties">The key columns in this table.</param>
    /// <param name="entityToInsert">The entity to insert.</param>
    /// <returns>The Id of the row created.</returns>
    public async Task<int> InsertAsync(IDbConnection connection, IDbTransaction transaction, int? commandTimeout,
        string tableName, string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties,
        object entityToInsert)
    {
        StringBuilder sb = new StringBuilder();
        sb.AppendFormat("INSERT INTO {0} ({1}) VALUES ({2})", tableName, columnList, parameterList);

        // If no primary key then safe to assume a join table with not too much data to return
        PropertyInfo[] propertyInfos = keyProperties as PropertyInfo[] ?? keyProperties.ToArray();
        if (propertyInfos.Length == 0)
        {
            sb.Append(" RETURNING *");
        }
        else
        {
            sb.Append(" RETURNING ");
            bool first = true;
            foreach (PropertyInfo property in propertyInfos)
            {
                if (!first)
                {
                    sb.Append(", ");
                }

                first = false;
                sb.Append(property.Name);
            }
        }

        IEnumerable<dynamic> results = await connection.QueryAsync(sb.ToString(), entityToInsert, transaction, commandTimeout)
            .ConfigureAwait(false);

        // Return the key by assinging the corresponding property in the object - by product is that it supports compound primary keys
        int id = 0;
        foreach (PropertyInfo p in propertyInfos)
        {
            object value = ((IDictionary<string, object>)results.First())[p.Name.ToLower()];
            p.SetValue(entityToInsert, value, null);
            if (id == 0)
            {
                id = Convert.ToInt32(value);
            }
        }

        return id;
    }
}

public partial class SQLiteAdapter
{
    /// <summary>
    ///     Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
    /// </summary>
    /// <param name="connection">The connection to use.</param>
    /// <param name="transaction">The transaction to use.</param>
    /// <param name="commandTimeout">The command timeout to use.</param>
    /// <param name="tableName">The table to insert into.</param>
    /// <param name="columnList">The columns to set with this insert.</param>
    /// <param name="parameterList">The parameters to set for this insert.</param>
    /// <param name="keyProperties">The key columns in this table.</param>
    /// <param name="entityToInsert">The entity to insert.</param>
    /// <returns>The Id of the row created.</returns>
    public async Task<int> InsertAsync(IDbConnection connection, IDbTransaction transaction, int? commandTimeout,
        string tableName, string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties,
        object entityToInsert)
    {
        string cmd = $"INSERT INTO {tableName} ({columnList}) VALUES ({parameterList}); SELECT last_insert_rowid() id";
        SqlMapper.GridReader multi = await connection.QueryMultipleAsync(cmd, entityToInsert, transaction, commandTimeout)
            .ConfigureAwait(false);

        int id = (int)multi.Read().First().id;
        PropertyInfo[] pi = keyProperties as PropertyInfo[] ?? keyProperties.ToArray();
        if (pi.Length == 0)
        {
            return id;
        }

        PropertyInfo idp = pi[0];
        idp.SetValue(entityToInsert, Convert.ChangeType(id, idp.PropertyType), null);

        return id;
    }
}

public partial class FbAdapter
{
    /// <summary>
    ///     Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
    /// </summary>
    /// <param name="connection">The connection to use.</param>
    /// <param name="transaction">The transaction to use.</param>
    /// <param name="commandTimeout">The command timeout to use.</param>
    /// <param name="tableName">The table to insert into.</param>
    /// <param name="columnList">The columns to set with this insert.</param>
    /// <param name="parameterList">The parameters to set for this insert.</param>
    /// <param name="keyProperties">The key columns in this table.</param>
    /// <param name="entityToInsert">The entity to insert.</param>
    /// <returns>The Id of the row created.</returns>
    public async Task<int> InsertAsync(IDbConnection connection, IDbTransaction transaction, int? commandTimeout,
        string tableName, string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties,
        object entityToInsert)
    {
        string cmd = $"insert into {tableName} ({columnList}) values ({parameterList})";
        await connection.ExecuteAsync(cmd, entityToInsert, transaction, commandTimeout).ConfigureAwait(false);

        PropertyInfo[] propertyInfos = keyProperties as PropertyInfo[] ?? keyProperties.ToArray();
        string keyName = propertyInfos[0].Name;
        IEnumerable<dynamic> r = await connection.QueryAsync($"SELECT FIRST 1 {keyName} ID FROM {tableName} ORDER BY {keyName} DESC",
            transaction: transaction, commandTimeout: commandTimeout).ConfigureAwait(false);

        dynamic id = r.First().ID;
        if (id == null)
        {
            return 0;
        }

        if (propertyInfos.Length == 0)
        {
            return Convert.ToInt32(id);
        }

        PropertyInfo idp = propertyInfos[0];
        idp.SetValue(entityToInsert, Convert.ChangeType(id, idp.PropertyType), null);

        return Convert.ToInt32(id);
    }
}