package me.km.databank;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import me.km.api.Module;
import me.km.table.Table;
import me.hammerle.snuviscript.code.Compiler;

public abstract class SimpleDataBank 
{
    private final DataBank c;
    private final Module m;
    
    public SimpleDataBank(Module m, DataBank c)
    {
        this.c = c;
        this.m = m;
    }
    
    public final Module getModule()
    {
        return m;
    }
    
    private void printException(String query, SQLException ex)
    {
        if(!c.isDummyDatabank())
        {
            m.sendWarningToConsole("Der folgende Query hat einen Error ausgelöst:");
            m.sendWarningToConsole(query);
            m.sendWarningToConsole(ex.toString());
        }
    }
    
    /** Führt den gegebenen Query aus und gibt den Erfolg zurück.
     *
     * @param query ein Query, irgendetwas mit "INSERT, UPDATE, ..."
     * @param ignore gibt keine Fehlermeldung aus, falls auf <code> true </code>
     * @return <code> true </code> falls kein Error auftrat, sonst <code> false </code>
     */
    public final boolean update(String query, boolean ignore)
    {
        try(Statement stmt = c.createStatement()) 
        {
            stmt.executeUpdate(query);
            return true;
        }
        catch(SQLException ex) 
        {
            if(!ignore)
            {
                printException(query, ex);
            }
            return false;
        }
    }
    
    /** Führt den gegebenen Query aus und gibt die erste Spalte der ersten Reihe zurück.
     *
     * @param <T> die Klasse der Rückgabe
     * @param query ein Query, irgendetwas mit "SELECT"
     * @param r die Klasse der Rückgabe
     * @return das gewünschte Objekt, null falls ein Fehler auftrat oder der ResultSet leer ist
     */
    @SuppressWarnings("unchecked")
    public final <T> T getFirst(String query, Class<T> r)
    {
        //System.out.println(query);
        try(Statement stmt = c.createStatement();)
        {
            ResultSet rs = stmt.executeQuery(query);
            if(rs.next())
            {
                return (T) rs.getObject(1);
            }
            return null;
        }
        catch(SQLException ex) 
        {
            printException(query, ex);
            return null;
        }
    }
    
    /** Führt den gegebenen Query aus und gibt die erste Spalte der ersten Reihe zurück.
     *
     * @param query ein Query, irgendetwas mit "SELECT"
     * @return der gewünschte Byte, null falls ein Fehler auftrat oder der ResultSet leer ist
     */
    public final Byte getFirstByte(String query)
    {
        //System.out.println(query);
        try(Statement stmt = c.createStatement();)
        {
            ResultSet rs = stmt.executeQuery(query);
            if(rs.next())
            {
                return rs.getByte(1);
            }
            return null;
        }
        catch(SQLException ex) 
        {
            printException(query, ex);
            return null;
        }
    }
    
    /** Führt den gegebenen Query aus und gibt alle Spalten der ersten Reihe zurück.
     *
     * @param query ein Query, irgendetwas mit "SELECT"
     * @return alle Spalten als Liste, bei einem Error kann sie null sein
     */
    @SuppressWarnings("unchecked")
    public final ArrayList<Object> getFirstRow(String query)
    {
        //System.out.println(query);
        ArrayList<Object> list = new ArrayList();
        try(Statement stmt = c.createStatement();)
        {
            ResultSet rs = stmt.executeQuery(query);
            if(rs.next())
            {
                int i = 1;
                while(true)
                {
                    list.add(rs.getObject(i));
                    i++;
                }
            }
            return list;
        }
        catch(SQLException ex) 
        {
            if(!ex.getLocalizedMessage().startsWith("Column Index"))
            {
                printException(query, ex);
                return null;
            }
            return list;
        }
    }

    /** Führt den gegebenen Query aus und gibt alle Zeilen der ersten Spalte zurück.
     *
     * @param query ein Query, irgendetwas mit "SELECT"
     * @return alle Spalten als Liste, bei einem Error kann sie null sein
     */
    @SuppressWarnings("unchecked")
    public final ArrayList<Object> getFirstColumn(String query)
    {
        //System.out.println(query);
        ArrayList<Object> list = new ArrayList();
        try(Statement stmt = c.createStatement();)
        {
            ResultSet rs = stmt.executeQuery(query);
            while(rs.next())
            {
                list.add(rs.getObject(1));
            }
            return list;
        }
        catch(SQLException ex) 
        {
            printException(query, ex);
            return null;
        }
        catch(IllegalStateException ex) 
        {
            return list;
        }
    }
    
    /** Führt den gegebenen Query aus und gibt alle Zeilen der ersten Spalte zurück.
     *
     * @param query ein Query, irgendetwas mit "SELECT"
     * @return alle Spalten als Liste, bei einem Error kann sie null sein
     */
    @SuppressWarnings("unchecked")
    public final ArrayList<Byte> getFirstByteColumn(String query)
    {
        //System.out.println(query);
        ArrayList<Byte> list = new ArrayList();
        try(Statement stmt = c.createStatement();)
        {
            ResultSet rs = stmt.executeQuery(query);
            while(rs.next())
            {
                list.add(rs.getByte(1));
            }
            return list;
        }
        catch(SQLException ex) 
        {
            printException(query, ex);
            return null;
        }
        catch(IllegalStateException ex) 
        {
            return list;
        }
    }
    
    /** Führt den gegebenen Query aus und gibt alle Spalten als Liste in einer Liste zurück.
     *
     * @param query ein Query, irgendetwas mit "SELECT"
     * @return alle Spalten als Liste in einer Liste, bei einem Error kann sie null sein
     */
    @SuppressWarnings("unchecked")
    public final ArrayList<ArrayList<Object>> get(String query)
    {
        //System.out.println(query);
        ArrayList<ArrayList<Object>> list = new ArrayList();
        try(Statement stmt = c.createStatement();)
        {
            ResultSet rs = stmt.executeQuery(query);
            while(rs.next())
            {
                ArrayList<Object> columns = new ArrayList();
                try
                {
                    int i = 1;
                    while(true)
                    {
                        columns.add(rs.getObject(i));
                        i++;
                    }
                }
                catch(SQLException ex) 
                {
                    if(!ex.getLocalizedMessage().startsWith("Column Index"))
                    {
                        printException(query, ex);
                        return null;
                    }
                }
                list.add(columns);
            }
            return list;
        }
        catch(SQLException ex) 
        {
            printException(query, ex);
            return null;
        }
        catch(IllegalStateException ex) 
        {
            return list;
        }
    }
    
    /** Führt den gegebenen Query aus und gibt zwei Spalten als Table zurück.
     *
     * @param query ein Query, irgendetwas mit "SELECT"
     * @return zwei Spalten als List-Map, bei einem Error kann sie null sein
     */
    public final Table getTable(String query)
    {
        Table table = new Table(2);
        try(Statement stmt = c.createStatement();)
        {
            ResultSet rs = stmt.executeQuery(query);
            while(rs.next())
            {
                table.addRow(new Object[] {rs.getString(1), Compiler.convert(rs.getString(2))});
            }
            return table;
        }
        catch(SQLException ex) 
        {
            printException(query, ex);
            return null;
        }
        catch(IllegalStateException ex) 
        {
            return table;
        }
    }
    
    /** Gibt zurück, ob eine Tabelle existiert oder nicht.
     *
     * @param table der Name der Tabelle
     * @return <code> true </code> falls die Tabelle existiert, sonst <code> false </code>
     */
    public final boolean doesTableExist(String table)
    {
        try(Statement stmt = c.createStatement();)
        {
            return stmt.executeQuery("SHOW TABLES IN minecraft LIKE '" + table + "';").next();
        }
        catch(SQLException ex) 
        {
            printException("SHOW TABLES LIKE '" + table + "';", ex);
            return false;
        }
    }
}