module htestmain;

import std.stdio;
import std..string;
import std.conv;
import dstruct.core;
import std.traits;

// Annotations of entity classes
@Table("usertests")
class User
{
    long id;

    string name;

    int some_field_with_underscore;

    @ManyToMany // cannot be inferred, requires annotation
    LazyCollection!Role roles;

    //@ManyToOne
    MyGroup group;

    @OneToMany Address[] addresses;

    Asset[] assets;

    override string toString()
    {
        return format("{id:%s, name:%s, roles:%s, group:%s}", id, name, roles, group);
    }
}

class Role
{
    int id;
    string name;
    @ManyToMany // w/o this annotation will be OneToMany by convention
    LazyCollection!User users;

    override string toString()
    {
        return format("{id:%s, name:%s}", id, name);
    }
}

class Address
{
    @Generated @Id int id;
    User user;
    string street;
    string town;
    string country;

    override string toString()
    {
        return format("{id:%s, user:%s, street:%s, town:%s, country:%s}", id,
                user, street, town, country);
    }
}

class Asset
{
    @Generated @Id int id;
    User user;
    string name;
}

@Entity class MyGroup
{
    long id;
    string name;
    @OneToMany LazyCollection!User users;

    override string toString()
    {
        return format("{id:%s, name:%s}", id, name);
    }
}

void testHibernate()
{
    version (USE_SQLITE)
    {
        import dstruct.ddbc.drivers.sqliteddbc;

        SQLITEDriver driver = new SQLITEDriver();
        string[string] params;
        DataSource ds = new ConnectionPoolDataSourceImpl(driver, "dstruct_tests.db", params);
        Dialect dialect = new SQLiteDialect();
    }
    else version (USE_PGSQL)
    {
        import dstruct.ddbc.drivers.pgsqlddbc;

        writeln("Using postgres for tests....");

        string url = PGSQLDriver.generateUrl("127.0.0.1", 5432, "dstruct_tests");

        string[string] params;
        params["user"] = "dstruct";
        params["password"] = "dstruct";
        params["ssl"] = "true";
        PGSQLDriver driver = new PGSQLDriver();
        DataSource ds = new ConnectionPoolDataSourceImpl(driver, url, params);
        Dialect dialect = new PGSQLDialect();
    }

    // create metadata from annotations
    writeln("Creating schema from class list");
    EntityMetaData schema = new SchemaInfoImpl!(User, Role, Address, Asset, MyGroup);
    writeln("Creating schema from module list");
    EntityMetaData schema2 = new SchemaInfoImpl!(htestmain);

    writeln("Creating session factory");
    // create session factory
    SessionFactory factory = new SessionFactoryImpl(schema, dialect, ds);
    scope (exit)
        factory.close();

    writeln("Creating DB schema");
    DBInfo db = factory.getDBMetaData();
    {
        Connection conn = ds.getConnection();
        scope (exit)
            conn.close();
        db.updateDBSchema(conn, true, true);
    }

    // create session
    Session sess = factory.openSession();
    scope (exit)
        sess.close();

    // use session to access DB

    writeln("Querying empty DB");
    Query q = sess.createQuery("FROM User ORDER BY name");
    User[] list = q.list!User();
    writeln("Result size is " ~ to!string(list.length));

    // create sample data
    writeln("Creating sample schema");
    MyGroup grp1 = new MyGroup();
    grp1.name = "Group-1";
    MyGroup grp2 = new MyGroup();
    grp2.name = "Group-2";
    MyGroup grp3 = new MyGroup();
    grp3.name = "Group-3";
    //
    Role r10 = new Role();
    r10.name = "role10";
    Role r11 = new Role();
    r11.name = "role11";

    // create a user called Alex with an address and an asset
    User u10 = new User();
    u10.name = "Alex";
    u10.roles = [r10, r11];
    u10.group = grp3;
    auto address = new Address();
    address.street = "Some Street";
    address.town = "Big Town";
    address.country = "Alaska";
    address.user = u10;
    writefln("Saving Address: %s", address);
    sess.save(address);

    u10.addresses = [address];
    auto asset = new Asset();
    asset.name = "Something Precious";
    asset.user = u10;
    writefln("Saving Asset: %s", asset);
    sess.save(asset);
    u10.assets = [asset];

    User u12 = new User();
    u12.name = "Arjan";
    u12.roles = [r10, r11];
    u12.group = grp2;

    User u13 = new User();
    u13.name = "Wessel";
    u13.roles = [r10, r11];
    u13.group = grp2;

    writeln("saving group 1-2-3");
    sess.save(grp1);
    sess.save(grp2);
    sess.save(grp3);

    writeln("Saving Role r10: " ~ r10.name);
    sess.save(r10);

    writeln("Saving Role r11: " ~ r11.name);
    sess.save(r11);

    writeln("Saving User u10: " ~ u10.name);
    sess.save(u10);

    writeln("Saving User u12: " ~ u12.name);
    sess.save(u12);

    writeln("Saving User u13: " ~ u13.name);
    sess.save(u13);

    writeln("Loading User");
    // load and check data
    auto qresult = sess.createQuery("FROM User WHERE name=:Name and some_field_with_underscore != 42")
        .setParameter("Name", "Alex");
    writefln("query result: %s", qresult.listRows());
    User u11 = qresult.uniqueResult!User();
    //User u11 = sess.createQuery("FROM User WHERE name=:Name and some_field_with_underscore != 42").setParameter("Name", "Alex").uniqueResult!User();
    writefln("Checking User 11 : %s", u11);
    assert(u11.roles.length == 2);
    assert(u11.roles[0].name == "role10" || u11.roles.get()[0].name == "role11");
    assert(u11.roles[1].name == "role10" || u11.roles.get()[1].name == "role11");
    assert(u11.roles[0].users.length == 3);
    assert(u11.roles[0].users[0] == u10);

    assert(u11.addresses.length == 1);
    assert(u11.addresses[0].street == "Some Street");
    assert(u11.addresses[0].town == "Big Town");
    assert(u11.addresses[0].country == "Alaska");

    assert(u11.assets.length == 1);
    assert(u11.assets[0].name == "Something Precious");

    // selecting all from address table should return a row that joins to the user table
    auto allAddresses = sess.createQuery("FROM Address").list!Address();
    assert(allAddresses.length == 1);
    writefln("Found address : %s", allAddresses[0]);
    assert(allAddresses[0].street == "Some Street");
    assert(allAddresses[0].user == u11);

    // selecting all from asset table should return a row that joins to the user table
    auto allAssets = sess.createQuery("FROM Asset").list!Asset();
    assert(allAssets.length == 1);
    writefln("Found asset : %s", allAssets[0]);
    assert(allAssets[0].name == "Something Precious");
    assert(allAssets[0].user == u11);

    // now test something else
    writeln("Test retrieving users by group... (ManyToOne relationship)");
    auto qUsersByGroup = sess.createQuery("FROM User WHERE group=:group_id")
        .setParameter("group_id", grp2.id);
    User[] usersByGroup = qUsersByGroup.list!User();
    assert(usersByGroup.length == 2); // user 2 and user 2

    //writeln("Removing User");
    // remove reference
    //std.algorithm.remove(u11.roles.get(), 0);
    //sess.update(u11);

    // remove entity
    //sess.remove(u11);
}

void main()
{
    testHibernate();
}