package solutions.bitbadger.documents

import solutions.bitbadger.documents.query.Count
import java.sql.Connection

/**
 * Functions to count documents
 */
object Count {

    /**
     * Count all documents in the table
     *
     * @param tableName The name of the table in which documents should be counted
     * @param conn The connection over which documents should be counted
     * @return A count of the documents in the table
     */
    fun all(tableName: String, conn: Connection) =
        conn.customScalar(Count.all(tableName), mapFunc = Results::toCount)

    /**
     * Count all documents in the table
     *
     * @param tableName The name of the table in which documents should be counted
     * @return A count of the documents in the table
     */
    fun all(tableName: String) =
        Configuration.dbConn().use { all(tableName, it) }

    /**
     * Count documents using a field comparison
     *
     * @param tableName The name of the table in which documents should be counted
     * @param fields The fields which should be compared
     * @param howMatched How the fields should be matched
     * @param conn The connection on which the deletion should be executed
     * @return A count of the matching documents in the table
     */
    fun byFields(
        tableName: String,
        fields: Collection<Field<*>>,
        howMatched: FieldMatch? = null,
        conn: Connection
    ): Long {
        val named = Parameters.nameFields(fields)
        return conn.customScalar(
            Count.byFields(tableName, named, howMatched),
            Parameters.addFields(named),
            Results::toCount
        )
    }

    /**
     * Count documents using a field comparison
     *
     * @param tableName The name of the table in which documents should be counted
     * @param fields The fields which should be compared
     * @param howMatched How the fields should be matched
     * @return A count of the matching documents in the table
     */
    fun byFields(tableName: String, fields: Collection<Field<*>>, howMatched: FieldMatch? = null) =
        Configuration.dbConn().use { byFields(tableName, fields, howMatched, it) }

    /**
     * Count documents using a JSON containment query (PostgreSQL only)
     *
     * @param tableName The name of the table in which documents should be counted
     * @param criteria The object for which JSON containment should be checked
     * @param conn The connection on which the deletion should be executed
     * @return A count of the matching documents in the table
     * @throws DocumentException If called on a SQLite connection
     */
    inline fun <reified T> byContains(tableName: String, criteria: T, conn: Connection) =
        conn.customScalar(Count.byContains(tableName), listOf(Parameters.json(":criteria", criteria)), Results::toCount)

    /**
     * Count documents using a JSON containment query (PostgreSQL only)
     *
     * @param tableName The name of the table in which documents should be counted
     * @param criteria The object for which JSON containment should be checked
     * @return A count of the matching documents in the table
     * @throws DocumentException If called on a SQLite connection
     */
    inline fun <reified T> byContains(tableName: String, criteria: T) =
        Configuration.dbConn().use { byContains(tableName, criteria, it) }

    /**
     * Count documents using a JSON containment query (PostgreSQL only)
     *
     * @param tableName The name of the table in which documents should be counted
     * @param path The JSON path comparison to match
     * @param conn The connection on which the deletion should be executed
     * @return A count of the matching documents in the table
     * @throws DocumentException If called on a SQLite connection
     */
    fun byJsonPath(tableName: String, path: String, conn: Connection) =
        conn.customScalar(
            Count.byJsonPath(tableName),
            listOf(Parameter(":path", ParameterType.STRING, path)),
            Results::toCount
        )

    /**
     * Count documents using a JSON containment query (PostgreSQL only)
     *
     * @param tableName The name of the table in which documents should be counted
     * @param path The JSON path comparison to match
     * @return A count of the matching documents in the table
     * @throws DocumentException If called on a SQLite connection
     */
    fun byJsonPath(tableName: String, path: String) =
        Configuration.dbConn().use { byJsonPath(tableName, path, it) }
}