import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;

public class Project {
    private ArrayList<Task> tasks = new ArrayList<>();
    private int countTasks;
    private int lastAssignedTaskId = -1;
    public ArrayList<Task> initialTasks = new ArrayList<>();
    private ArrayList<Task> nodesSeen = new ArrayList<>(); //I found this was the easiest way to do realisability
    public Project(String fileDirectory) {
        File inFile = new File(fileDirectory);
        readFromFile(inFile);
        for (Task task : tasks) {
            for (Task compareTask : tasks) {
                if (task.getPredecessors().contains(compareTask.getTaskNumber())) {
                    compareTask.addOutEdge(task);
                }
            }
            if (task.getPredecessors().isEmpty()) {
                initialTasks.add(task);
            }
        }
    }
    private void readFromFile(File inFile) {
        try {
            FileReader fileReader = new FileReader(inFile);
            BufferedReader bufferedReader = new BufferedReader(fileReader);
            String line;
            setCountTasks(Integer.parseInt(bufferedReader.readLine()));
            bufferedReader.readLine();
            bufferedReader.readLine(); //pass the two empty lines in the source files
            while ((line = bufferedReader.readLine()) != null) {
                String[] fileData = line.split( "\\s+");
                int taskNumber = Integer.parseInt(fileData[0]);
                String taskName = fileData[1];
                int taskTime = Integer.parseInt(fileData[2]);
                int taskManpower =  Integer.parseInt(fileData[3]);
                ArrayList<Integer> predecessors = new ArrayList<>();
                for (int i = 4 ; i <= fileData.length-1 ; i++) {
                    predecessors.add(Integer.parseInt(fileData[i]));
                }
                predecessors.remove( predecessors.size()-1); //remove the trailing 0; less error-prone than reducing loop length
                Task task = new Task(assignId(), taskTime, taskManpower, taskName, predecessors.size());
                task.setNumber(taskNumber);
                task.setPredecessors(predecessors);
                tasks.add(task);
                assert tasks.size() == countTasks;
            }
            bufferedReader.close();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
    public void confirmRealisable() {
        for (Task node : initialTasks) {
            confirmRealisableRecursive(node);
        }
        nodesSeen.clear();
    }
    public void confirmRealisableRecursive(Task node) {
        nodesSeen.add(node);
        for (Task task : node.getOutEdges()) {
            if (!nodesSeen.contains(task)) {
                confirmRealisableRecursive(task);
            } else {
                System.out.println("Cycle detected: ");
                System.out.println();
                for (Task cycleNode : nodesSeen) {
                    if (cycleNode.getTaskNumber() != nodesSeen.size()) {
                        System.out.print(cycleNode.getTaskNumber() + " -> ");
                    } else {
                        System.out.print(cycleNode.getTaskNumber());
                    }
                }
            }
        }
        nodesSeen.remove(node);
    }
    public void optimalTimeSchedule() {
        ArrayList<Integer> completed = new ArrayList<>();
        ArrayList<Task> underway = new ArrayList<>();
        ArrayList<Task> taskList = new ArrayList<>();
        ArrayList<Task> pruneList = new ArrayList<>();
        for (Task task : tasks) {
            taskList.add(task);
        }
        int time = 0;
        int staff;
        while (completed.size() < countTasks) {
            boolean printed = false;
            for (Task task : taskList) {
                boolean add = true;
                if (!task.getPredecessors().isEmpty()) {
                    for (int pred : task.getPredecessors()) {
                        if (!completed.contains(pred)) {
                            add = false;
                        }
                    }
                }
                if (add && !underway.contains(task)) {
                    underway.add(task);
                    pruneList.add(task);
                }
            }
            for (Task task : pruneList) {
                taskList.remove(task);
            }
            pruneList.clear();
            staff = 0;
            for (Task task : underway) {
                staff = staff + task.getStaff();
                if (task.getTime() == task.getTimeCounter()) {
                    if (!printed) {
                        System.out.println("Current time: " + time);
                        System.out.println("Current staff: " + staff);
                        printed = true;
                    }
                    System.out.println("Starting: " + task.getTaskNumber() + " - " + task.getName());
                }
                if (task.getTimeCounter() == 0) {
                    if (!printed) {
                        System.out.println("Current time: " + time);
                        System.out.println("Current staff: " + staff);
                        printed = true;
                    }
                    pruneList.add(task);
                    completed.add(task.getTaskNumber());
                    System.out.println("Completed: " + task.getTaskNumber() + " - " + task.getName());
                }
            }
            for (Task task : pruneList) {
                underway.remove(task);
            }
            pruneList.clear();
            time++;
            for (Task task : underway) {
                task.decrementTimeCounter();
            }
        }
    }
    private void setCountTasks(int count) {
        countTasks = count;
    }
    private int assignId() {
        lastAssignedTaskId++;
        return lastAssignedTaskId;
    }
}