package io.trygvis.persistence;

import io.trygvis.container.compiler.SqlUnitModel;
import io.trygvis.container.compiler.model.Imports;
import io.trygvis.container.compiler.model.MethodRef;
import io.trygvis.container.compiler.model.TypeRef;
import io.trygvis.persistence.generators.DaoGenerator;
import io.trygvis.persistence.generators.DaoUtilsGenerator;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

import java.io.CharArrayWriter;
import java.io.PrintWriter;

import static io.trygvis.container.compiler.Utils.EOL;
import static io.trygvis.persistence.FieldMirror.FieldType.PRIMITIVE;
import static io.trygvis.persistence.FieldMirror.FieldType.REFERENCE;
import static io.trygvis.persistence.FieldMirror.GetterType;
import static io.trygvis.persistence.FieldMirror.SetterType;
import static java.lang.String.format;
import static org.testng.Assert.assertEquals;

public class EntityMirrorTest {

    GeneratorConfiguration generatorConfiguration = new GeneratorConfiguration();

    static TypeRef entityType = new TypeRef("Wat");
    static FieldMirror idLong = new FieldMirror(PRIMITIVE, SetterType.CONSTRUCTOR, GetterType.FIELD,
            new TypeRef(Long.class), "id", "id", true, false, true);
    static FieldMirror idString = new FieldMirror(PRIMITIVE, SetterType.CONSTRUCTOR, GetterType.FIELD,
            new TypeRef(String.class), "id", "id", true, false, true);
    static FieldMirror idMethod = new FieldMirror(PRIMITIVE, SetterType.CONSTRUCTOR, GetterType.METHOD,
            new TypeRef(Long.class), "id", "id", true, false, true);
    static FieldMirror name = new FieldMirror(PRIMITIVE, SetterType.CONSTRUCTOR, GetterType.FIELD,
            new TypeRef(String.class), "name", "name", false, false, false);
    static FieldMirror age = new FieldMirror(PRIMITIVE, SetterType.CONSTRUCTOR, GetterType.FIELD,
            new TypeRef(Integer.class), "age", "age", false, true, false);
    static FieldMirror year = new FieldMirror(PRIMITIVE, SetterType.CONSTRUCTOR, GetterType.METHOD,
            new TypeRef(Integer.class), "year", "year", false, true, false);
    static FieldMirror ref = new FieldMirror(REFERENCE, SetterType.CONSTRUCTOR, GetterType.FIELD,
            entityType, "parent", "parent", false, false, false);

    @DataProvider(name = "insertIntoSql", parallel = true)
    public static Object[][] insertIntoProvider() {
        return new Object[][]{
                new Object[]{
                        new FieldMirror[]{idString},
                        "INSERT INTO my_table(id) VALUES(nextval('id_seq'));",
                        "DELETE FROM my_table WHERE id=?;", format(
                        "CREATE TABLE my_table(%n" +
                                "  id VARCHAR(1000) PRIMARY KEY%n" +
                                ");")},
                new Object[]{
                        new FieldMirror[]{idLong},
                        "INSERT INTO my_table(id) VALUES(nextval('id_seq'));",
                        "DELETE FROM my_table WHERE id=?;", format(
                        "CREATE TABLE my_table(%n" +
                                "  id BIGINT PRIMARY KEY%n" +
                                ");")},
                new Object[]{
                        new FieldMirror[]{idLong, name},
                        "INSERT INTO my_table(id, name) VALUES(nextval('id_seq'), ?);",
                        "DELETE FROM my_table WHERE id=?;", format(
                        "CREATE TABLE my_table(%n" +
                                "  id BIGINT PRIMARY KEY,%n" +
                                "  name VARCHAR(1000)%n" +
                                ");")},
                new Object[]{
                        new FieldMirror[]{idLong, ref},
                        "INSERT INTO my_table(id, parent) VALUES(nextval('id_seq'), ?);",
                        "DELETE FROM my_table WHERE id=?;", format(
                        "CREATE TABLE my_table(%n" +
                                "  id BIGINT PRIMARY KEY,%n" +
                                "  parent BIGINT REFERENCES my_table(id)%n" +
                                ");")},
        };
    }

    @Test(dataProvider = "insertIntoSql")
    public void testInsertIntoSql(FieldMirror[] fields, String insert, String delete, String create) throws Exception {
        EntityMirror myTable = new EntityMirror(new GeneratorConfiguration(), entityType, true, null, "my_table");
        for (FieldMirror field : fields) {
            myTable.add(field);
        }

        SqlUnitModel unit = new SqlUnitModel().add(myTable).add(new SequenceMirror("seq-gen", "id_seq", 0, 0));
        DaoGenerator generator = new DaoGenerator(generatorConfiguration, unit, myTable);

        assertEquals(generator.insertIntoSql(), insert);
        assertEquals(generator.deleteFromSql(), delete);
        assertEquals(generator.createTableSql(), create);
    }

    @DataProvider(name = "insertIntoMethod", parallel = true)
    public static Object[][] insertIntoMethodProvider() {
        return new Object[][]{
                new Object[]{new FieldMirror[]{name}, join(
                        "try (java.sql.PreparedStatement stmt = con.prepareStatement(insertIntoSql)) {",
                        "    java.lang.String name = o.name;",
                        "    if (name == null) {",
                        "        stmt.setNull(1, java.sql.Types.VARCHAR);",
                        "    } else {",
                        "        stmt.setString(1, o.name);",
                        "    }",
                        "    stmt.executeUpdate();",
                        "}")
                },
                new Object[]{new FieldMirror[]{year}, join(
                        "try (java.sql.PreparedStatement stmt = con.prepareStatement(insertIntoSql)) {",
                        "    stmt.setInt(1, o.getYear());",
                        "    stmt.executeUpdate();",
                        "}")
                },
                new Object[]{new FieldMirror[]{age, year, idLong}, join(
                        "try (java.sql.PreparedStatement stmt = con.prepareStatement(insertIntoSql)) {",
                        "    stmt.setInt(1, o.age);",
                        "    stmt.setInt(2, o.getYear());",
                        "    stmt.executeUpdate();",
                        "}")
                },
        };
    }

    @Test(dataProvider = "insertIntoMethod")
    public void testInsertIntoMethod(FieldMirror[] fields, String expected) {
        eq(insertInto(fields), expected.trim());
    }

    private MethodRef insertInto(FieldMirror... fields) {
        EntityMirror myTable = new EntityMirror(generatorConfiguration, entityType, true, null, "my_table");
        myTable.add(fields);
        SqlUnitModel unit = new SqlUnitModel().add(myTable);
        return new DaoUtilsGenerator(unit, generatorConfiguration, myTable).insertInto(new Imports());
    }

    @DataProvider(name = "deleteMethod", parallel = true)
    public static Object[][] deleteMethodProvider() {
        return new Object[][]{
                new Object[]{new FieldMirror[]{idLong}, join(
                        "deleteWatById(con, o.id);")
                },
                new Object[]{new FieldMirror[]{idMethod}, join(
                        "deleteWatById(con, o.getId());")
                },
        };
    }

    @Test(dataProvider = "deleteMethod")
    public void testDeleteMethod(FieldMirror[] fields, String expected) {
        eq(delete(fields), expected.trim());
    }

    private MethodRef delete(FieldMirror... fields) {
        EntityMirror myTable = new EntityMirror(new GeneratorConfiguration(), entityType, true, null, "my_table");
        myTable.add(fields);
        SqlUnitModel unit = new SqlUnitModel().add(myTable);
        return new DaoUtilsGenerator(unit, generatorConfiguration, myTable).delete(new Imports());
    }

    @DataProvider(name = "deleteByIdMethod", parallel = true)
    public static Object[][] deleteByIdMethodProvider() {
        return new Object[][]{
                new Object[]{new FieldMirror[]{idLong}, join(
                        "try (java.sql.PreparedStatement stmt = con.prepareStatement(deleteFromSql)) {",
                        "    stmt.setLong(1, id);",
                        "    stmt.executeUpdate();",
                        "}")
                },
                new Object[]{new FieldMirror[]{idMethod}, join(
                        "try (java.sql.PreparedStatement stmt = con.prepareStatement(deleteFromSql)) {",
                        "    stmt.setLong(1, id);",
                        "    stmt.executeUpdate();",
                        "}")
                },
        };
    }

    @Test(dataProvider = "deleteByIdMethod")
    public void testDeleteByIdMethod(FieldMirror[] fields, String expected) {
        eq(deleteById(fields), expected.trim());
    }

    private MethodRef deleteById(FieldMirror... fields) {
        EntityMirror myTable = new EntityMirror(new GeneratorConfiguration(), entityType, true, null, "my_table");
        myTable.add(fields);
        SqlUnitModel unit = new SqlUnitModel().add(myTable);
        return new DaoUtilsGenerator(unit, generatorConfiguration, myTable).deleteById(new Imports());
    }

//    @Test
//    public void testFromResultSet() {
//        eq(fromResultSet(age),
//                "java.lang.Integer age = rs.getInt(1);",
//                "Wat returnValue = new Wat(age);",
//                "return returnValue;");
//
//        eq(fromResultSet(age, year),
//                "java.lang.Integer age = rs.getInt(1);",
//                "Wat returnValue = new Wat(age);",
//                "returnValue.setYear(rs.getInt(2));",
//                "return returnValue;");
//
//        eq(fromResultSet(age, year, name),
//                "java.lang.Integer age = rs.getInt(1);",
//                "java.lang.String name = rs.getString(3);",
//                "Wat returnValue = new Wat(age, name);",
//                "returnValue.setYear(rs.getInt(2));",
//                "return returnValue;");
//    }

//    private MethodRef fromResultSet(FieldMirror... fields) {
//        EntityMirror myTable = new EntityMirror(new GeneratorConfiguration(), entityType, "my_table");
//        myTable.add(fields);
//        SqlUnitModel unit = new SqlUnitModel().add(myTable);
//        return new DaoUtilsGenerator(unit, generatorConfiguration, myTable).fromResultSet(new Imports());
//    }

    private void eq(MethodRef m, String... expected) {
        CharArrayWriter actual = new CharArrayWriter();
        PrintWriter w = new PrintWriter(actual);
        for (String s : m.body) {
            w.println(s);
        }

        CharArrayWriter e = new CharArrayWriter();
        w = new PrintWriter(e);
        for (String s : expected) {
            w.println(s);
        }

        assertEquals(actual.toString(), e.toString());
    }

    private static String join(String... strings) {
        StringBuilder buffer = new StringBuilder();
        for (String string : strings) {
            buffer.append(string).append(EOL);
        }
        return buffer.toString();
    }
}