import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteStatement;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DatabaseMigrator {

    private abstract static class Parser<T> {

        Class<T> classOfT;

        Parser(Class<T> classOfT) {
            this.classOfT = classOfT;
        }

        public abstract T get(Cursor c, int index);

        public abstract void bind(SQLiteStatement statement, int index, Object value);


    }

    static List<Parser> supportedParsers = new ArrayList<>();

    static {
        supportedParsers.add(new Parser<Integer>(Integer.class) {
            @Override
            public Integer get(Cursor c, int index) {
                return c.getInt(index);
            }

            @Override
            public void bind(SQLiteStatement statement, int index, Object value) {
                statement.bindLong(index, (Long) value);
            }
        });
        supportedParsers.add(new Parser<Long>(Long.class){
            @Override
            public Long get(Cursor c, int index) {
                return c.getLong(index);
            }

            @Override
            public void bind(SQLiteStatement statement, int index, Object value) {
                statement.bindLong(index, (Long) value);
            }
        });
        supportedParsers.add(new Parser<String>(String.class){
            @Override
            public String get(Cursor c, int index) {
                return c.getString(index);
            }

            @Override
            public void bind(SQLiteStatement statement, int index, Object value) {
                statement.bindString(index, (String) value);
            }
        });
        supportedParsers.add(new Parser<Double>(Double.class){
            @Override
            public Double get(Cursor c, int index) {
                return c.getDouble(index);
            }

            @Override
            public void bind(SQLiteStatement statement, int index, Object value) {
                statement.bindDouble(index, (Double) value);
            }
        });
        supportedParsers.add(new Parser<Float>(Float.class){
            @Override
            public Float get(Cursor c, int index) {
                return c.getFloat(index);
            }

            @Override
            public void bind(SQLiteStatement statement, int index, Object value) {
                statement.bindDouble(index, (Double) value);
            }
        });
    }

    public static void migrate(SQLiteDatabase db, String oldTable, String newTable, Map<String, String> columnMap, List<Class> oldClasses, List<Class> newClasses) {
        Cursor c = getAllValues(db, oldTable, getCollectionAsArray(columnMap.keySet()));
        if(c.moveToFirst()) {
            do {
                Object []values = getObjectsFromCursor(c, oldClasses);
                String argsSymbol = getCollectionAsArgsSymbol(values);
                String insertStatement = "INSERT INTO " + newTable + "(" + getCollectionAsString(columnMap.values()) + ") VALUES(" + argsSymbol + ")";
                SQLiteStatement mStatement = db.compileStatement(insertStatement);
                insert(mStatement, newClasses, values);
            } while (c.moveToNext());
        }
        c.close();
    }

    protected static Object [] getObjectsFromCursor(Cursor c, List<Class> classes) {
        Object []objects = new Object[c.getColumnCount()];
        for(int i = 0; i < c.getColumnCount(); i++) {
            objects[i] = getAs(i, c, classes.get(i));
        }
        return objects;
    }

    protected static void bindValues(SQLiteStatement mStatement, Object []values, List<Class> newClasses) {
        mStatement.clearBindings();
        for(int i = 0; i < values.length; i++) {
            bindAs(mStatement, i, values[i], newClasses.get(i));
        }
    }

    private static Object getAs(int index, Cursor c, Class clazz) {
        Object obj = null;
        for(Parser parser : supportedParsers) {
            if(parser.classOfT == clazz) {
                obj = parser.get(c, index);
            }
        }
        return obj;
    }

    private static void bindAs(SQLiteStatement mStatement, int index, Object value, Class clazz) {
        if(value==null) {
            mStatement.bindNull(index);
            return;
        }
        for(Parser<?> parser : supportedParsers) {
            if(parser.classOfT == clazz) {
                parser.bind(mStatement, index, value);
            }
        }
    }

    private static Cursor getAllValues(SQLiteDatabase db, String table, String []columns) {
        return db.query(table, columns, null, null, null, null, null);
    }

    private static void insert(SQLiteStatement mStatement, List<Class> newClasses, Object[] values) {
        try {
            bindValues(mStatement, values, newClasses);
            mStatement.executeInsert();
        } catch (SQLiteException sqle) {
            sqle.printStackTrace();
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }

    public static Map<String, String> createMap(String... columns) {
        if(columns==null || columns.length % 2 != 0 || columns.length == 0) {
            throw new IllegalArgumentException("There should be even non-zero number of columns");
        }
        Map<String, String> columnMap = new HashMap<>();
        for(int i = 0; i < columns.length; i = i + 2) {
            columnMap.put(columns[i], columns[i+1]);
        }
        return columnMap;
    }

    private static String getCollectionAsString(Collection<String> set) {
        StringBuilder sb = new StringBuilder();
        int i = 0;
        for(String str : set) {
            sb.append(str);
            if(i != set.size()-1) {
                sb.append(", ");
            }
            i++;
        }
        return sb.toString();
    }

    private static String []getCollectionAsArray(Collection<String> set) {
        String []strings = new String[set.size()];
        int i = 0;
        for(String str : set) {
            strings[i] = str;
            i++;
        }
        return strings;
    }

    private static String getCollectionAsArgsSymbol(Object []values) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < values.length; i++) {
            sb.append("?");
            if(i != values.length-1) {
                sb.append(", ");
            }
            i++;
        }
        return sb.toString();
    }
}