import os
import re
from collections import defaultdict

class AutoSysJobVisualizer:
    def __init__(self, root_folder):
        self.root_folder = root_folder
        self.all_jobs = {}
        self.box_jobs = defaultdict(list)
        self.box_names = set()

    def parse_jil_file(self, file_path):
        jobs = {}
        current_job = None
        with open(file_path, 'r') as file:
            for line in file:
                line = line.strip()
                if line.startswith('insert_job:'):
                    current_job = line.split()[1]
                    jobs[current_job] = {'conditions': [], 'box_name': None}
                elif line.startswith('condition:') and current_job:
                    conditions = re.findall(r'([sdfn])\((.*?)\)', line)
                    jobs[current_job]['conditions'].extend(conditions)
                elif line.startswith('box_name:') and current_job:
                    box_name = line.split()[1]
                    jobs[current_job]['box_name'] = box_name
                    self.box_jobs[box_name].append(current_job)
                    self.box_names.add(box_name)
        return jobs

    def find_all_dependencies(self, jobs):
        dependencies = defaultdict(list)
        for job, details in jobs.items():
            for condition_type, condition_job in details['conditions']:
                dependencies[condition_job].append((job, f'con: {condition_type}'))
            if details['box_name']:
                box_name = details['box_name']
                dependencies[box_name].append((job, 'box: contains'))
        return dependencies

    def find_paths(self, start, end, dependencies, path=None):
        if path is None:
            path = []
        path = path + [start]
        if start == end:
            return [path]
        if start not in dependencies:
            return []
        paths = []
        for node, dep_type in dependencies[start]:
            if node not in path:
                new_paths = self.find_paths(node, end, dependencies, path)
                for p in new_paths:
                    paths.append(p)
        return paths

    def find_all_relationships(self, job1, job2, dependencies):
        paths = self.find_paths(job1, job2, dependencies)
        return paths

    def run(self, output_file, job1, job2):
        for dirpath, _, filenames in os.walk(self.root_folder):
            for filename in filenames:
                if filename.endswith('.jil'):
                    file_path = os.path.join(dirpath, filename)
                    jobs = self.parse_jil_file(file_path)
                    self.all_jobs.update(jobs)

        dependencies = self.find_all_dependencies(self.all_jobs)
        relationships = self.find_all_relationships(job1, job2, dependencies)

        output = "\nRelationships between jobs:\n"
        for path in relationships:
            detailed_path = []
            for i in range(len(path) - 1):
                node, next_node = path[i], path[i + 1]
                for dep in dependencies[node]:
                    if dep[0] == next_node:
                        detailed_path.append(f"{node} ({dep[1]})")
            detailed_path.append(path[-1])
            output += " -> ".join(detailed_path) + "\n"

        with open(output_file, 'w') as file:
            file.write(output)

if __name__ == "__main__":
    root_folder = '/path/to/your/jil/files'  # Change to your JIL files directory
    output_file = 'output.txt'  # Change to your desired output file path
    job1 = 'job_a'  # Change to the first job/box name
    job2 = 'job_b'  # Change to the second job/box name
    visualizer = AutoSysJobVisualizer(root_folder)
    visualizer.run(output_file, job1, job2)