package io.trygvis;

import io.trygvis.queue.AsyncService;
import io.trygvis.queue.Queue;
import io.trygvis.queue.Task;
import org.hibernate.dialect.PostgreSQL82Dialect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.bridge.SLF4JBridgeHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import static java.lang.System.*;
import static java.lang.Thread.sleep;

@Component
public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);

    public static void main(String[] args) throws Exception {
        SLF4JBridgeHandler.install();

        String username = getProperty("user.name");
        setProperty("database.url", getProperty("jdbc.url", "jdbc:postgresql://localhost/" + username));
        setProperty("database.username", username);
        setProperty("database.password", username);
//        setProperty("hibernate.showSql", "true");
        setProperty("hibernate.hbm2ddl.auto", "create"); // create
        setProperty("hibernate.dialect", PostgreSQL82Dialect.class.getName());

        log.info("Starting context");
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        log.info("Started context");

        try {
            context.getBean(Main.class).run();
//            log.info("Sleeping");
//            sleep(1000 * 1000);
        } catch (Exception e) {
            e.printStackTrace(System.out);
        }

        log.info("Stopping context");
        context.stop();
        log.info("Stopped context");

        exit(0);
    }

    @Autowired
    private TransactionTemplate transactionTemplate;

    @Autowired
    private AsyncService asyncService;

    @Autowired
    @Qualifier("createArticle")
    private AsyncService.AsyncCallable createArticleCallable;

    @Autowired
    @Qualifier("updateArticle")
    private AsyncService.AsyncCallable updateArticleCallable;

    public void run() throws Exception {
        log.info("Main.run");

        final Queue q = asyncService.registerQueue("create-article", 1, createArticleCallable);
//        log.info("queue registered: ref = {}", q);
//        asyncService.registerQueue("update-queue", 1, updateArticleCallable);

//        q = asyncService.getQueue("create-queue");

        final List<Task> tasks = new ArrayList<>();

        final int count = 1;
        log.info("Creating {} tasks", count);
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                for (int i = 0; i < count; i++) {
                    tasks.add(asyncService.schedule(q));
                }
            }
        });
        log.info("Created {} tasks", count);

        while (true) {
            sleep(10000);

            log.info("Checking for status of {} tasks", tasks.size());
            for (Iterator<Task> iterator = tasks.iterator(); iterator.hasNext(); ) {
                Task task = iterator.next();

                task = asyncService.update(task);

//                log.info("task = {}", task);

                if (task.isDone()) {
                    iterator.remove();
                }
            }

            if (tasks.isEmpty()) {
                log.info("No more tasks");
                break;
            }
        }
    }
}