package io.trygvis.test.spring;

import io.trygvis.async.AsyncService;
import io.trygvis.queue.QueueExecutor;
import io.trygvis.queue.QueueService;
import io.trygvis.queue.Task;
import io.trygvis.queue.TaskEffect;
import io.trygvis.spring.DefaultConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.sql.SQLException;
import java.util.Date;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;

import static java.lang.System.getProperty;
import static java.lang.System.setProperty;
import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
import static org.fest.assertions.Assertions.assertThat;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {TestConfig.class, DefaultConfig.class})
public class PlainSpringTest {

    @Autowired
    private AsyncService asyncService;

    @Autowired
    private QueueService queueService;

    private final QueueService.TaskExecutionRequest req = new QueueService.TaskExecutionRequest(100, true);

    static {
        String username = getProperty("user.name");
        setProperty("database.url", getProperty("jdbc.url", "jdbc:postgresql://localhost/" + username));
        setProperty("database.username", username);
        setProperty("database.password", username);
    }

    @Test
    public void testBasic() throws SQLException, InterruptedException {
        QueueExecutor queueA = queueService.getQueue("a", 1000, true);
//        final AtomicReference<List<String>> refA = new AtomicReference<>();
        asyncService.registerQueue(queueA.queue, req, new TaskEffect() {
            @Override
            public List<Task> apply(Task task) throws Exception {
//                refA.set(task.arguments);
//                synchronized (refA) {
//                    refA.notify();
//                }
                System.out.println("task.arguments = " + task.arguments);
                return asList(task.childTask("b", new Date(), task.arguments.get(0), "world"));
            }
        });

        QueueExecutor queueB = queueService.getQueue("b", 1000, true);
        final AtomicReference<List<String>> refB = new AtomicReference<>();
        asyncService.registerQueue(queueB.queue, req, new TaskEffect() {
            @Override
            public List<Task> apply(Task task) throws Exception {
//                System.out.println("task.arguments = " + task.arguments);
                refB.set(task.arguments);
                synchronized (refB) {
                    refB.notify();
                }
                return emptyList();
            }
        });

        synchronized (refB) {
            System.out.println("Scheduling task");
            queueService.schedule(queueA.queue, new Date(), asList("hello"));
            System.out.println("Task scheduled, waiting");
            refB.wait(10000);
            System.out.println("Back!");
        }

//        System.out.println("refA.get() = " + refA.get());
        System.out.println("refB.get() = " + refB.get());

        assertThat(refB.get()).containsExactly("hello", "world");
    }
}