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.PrimitiveFieldMirror;
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 PrimitiveFieldMirror(new TypeRef(Long.class), "id", "id", true, false, true);
    static FieldMirror idString = new PrimitiveFieldMirror(new TypeRef(String.class), "id", "id", true, false, true);
    static FieldMirror name = new PrimitiveFieldMirror(new TypeRef(String.class), "name", "name", false, false, false);
    static FieldMirror age = new PrimitiveFieldMirror(new TypeRef(Integer.class), "age", "age", false, true, false);
    static FieldMirror ref = new FieldMirror.ReferenceFieldMirror(entityType, "parent", "parent", 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(?);",
                        "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(?);",
                        "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(?, ?);",
                        "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(?, ?);",
                        "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);

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

    @Test
    public void testInsertIntoMethod() {
        eq(insertInto(idString),
                "try(java.sql.PreparedStatement stmt = con.prepareStatement(insertIntoSql)) {",
                "    java.lang.String id = o.id;",
                "    if(id == null) {",
                "        stmt.setNull(1, java.sql.Types.VARCHAR);",
                "    } else {",
                "        stmt.setString(1, o.id);",
                "    }",
                "    stmt.executeUpdate();",
                "}");

        eq(insertInto(age),
                "try(java.sql.PreparedStatement stmt = con.prepareStatement(insertIntoSql)) {",
                "    stmt.setInt(1, o.age);",
                "    stmt.executeUpdate();",
                "}");
    }

    @Test
    public void testFromResultSet() {
        eq(fromResultSet(age),
                "java.lang.Integer age = rs.getInt(1);",
                "return new Wat(age);");
    }

    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());
    }

    private MethodRef fromResultSet(FieldMirror... fields) {
        EntityMirror myTable = new EntityMirror(new GeneratorConfiguration(), entityType, "my_table");
        myTable.add(fields);
        SqlUnitModel unit = new SqlUnitModel().add(myTable);
        return myTable.fromResultSet(unit, 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());
    }
}