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 org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

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

import static io.trygvis.persistence.FieldMirror.AccessorType.FIELD;
import static io.trygvis.persistence.FieldMirror.AccessorType.METHOD;
import static io.trygvis.persistence.FieldMirror.FieldType.PRIMITIVE;
import static io.trygvis.persistence.FieldMirror.FieldType.REFERENCE;
import static java.lang.String.format;
import static org.testng.Assert.assertEquals;

public class EntityMirrorTest {

    static TypeRef entityType = new TypeRef("Wat");
    static FieldMirror idLong = new FieldMirror(PRIMITIVE, FIELD, new TypeRef(Long.class), "id", "id", true, false, true);
    static FieldMirror idString = new FieldMirror(PRIMITIVE, FIELD, new TypeRef(String.class), "id", "id", true, false, true);
    static FieldMirror idMethod = new FieldMirror(PRIMITIVE, METHOD, new TypeRef(Long.class), "id", "id", true, false, true);
    static FieldMirror name = new FieldMirror(PRIMITIVE, FIELD, new TypeRef(String.class), "name", "name", false, false, false);
    static FieldMirror age = new FieldMirror(PRIMITIVE, FIELD, new TypeRef(Integer.class), "age", "age", false, true, false);
    static FieldMirror year = new FieldMirror(PRIMITIVE, METHOD, new TypeRef(Integer.class), "year", "year", false, true, false);
    static FieldMirror ref = new FieldMirror(REFERENCE, 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, "my_table");
        for (FieldMirror field : fields) {
            myTable.add(field);
        }

        SqlUnitModel unit = new SqlUnitModel().add(myTable).add(new SequenceMirror("id_seq"));

        assertEquals(myTable.insertIntoSql(unit), insert);
        assertEquals(myTable.deleteFromSql(), delete);
        assertEquals(myTable.createTableSql(unit), 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[]{age}, join(
                        "try(java.sql.PreparedStatement stmt = con.prepareStatement(insertIntoSql)) {",
                        "    stmt.setInt(1, o.age);",
                        "    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(new GeneratorConfiguration(), entityType, "my_table");
        myTable.add(fields);
        SqlUnitModel unit = new SqlUnitModel().add(myTable);
        return myTable.insertInto(unit, new Imports());
    }

    @DataProvider(name = "deleteMethod", parallel = true)
    public static Object[][] deleteMethodProvider() {
        return new Object[][]{
                new Object[]{new FieldMirror[]{idLong}, join(
                        "deleteById(con, o.id);")
                },
                new Object[]{new FieldMirror[]{idMethod}, join(
                        "deleteById(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, "my_table");
        myTable.add(fields);
        return 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, "my_table");
        myTable.add(fields);
        return 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);
        return 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("\n");
        }
        return buffer.toString();
    }
}