#!/usr/bin/env python3
# Copyright (C) 2025 Apple Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1.  Redistributions of source code must retain the above copyright
#     notice, this list of conditions and the following disclaimer.
# 2.  Redistributions in binary form must reproduce the above copyright
#     notice, this list of conditions and the following disclaimer in the
#     documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import json
import os
import re

SYSTEM_HEADER_INCLUDE_PATTERN_REGEX = re.compile(r'\s*\#include\s+\<(?P<include>.+)\>\s*')
LOCAL_HEADER_INCLUDE_PATTERN_REGEX = re.compile(r'\s*\#include\s+"(?P<include>.+)"\s*')

def main():
    root_dir = os.path.realpath(os.path.join(os.path.dirname(__file__), '../../'))
    source_dir = os.path.join(root_dir, 'Source')
    derived_sources_dir = os.path.join(root_dir, 'WebKitBuild', 'Release', 'DerivedSources')
    if not os.path.isdir(derived_sources_dir):
        derived_sources_dir = os.path.join(root_dir, 'WebKitBuild', 'Debug', 'DerivedSources')
        if not os.path.isdir(derived_sources_dir):
            print('No valid WebKitBuild directory')
            derived_sources_dir = None

    projects = []
    for dir_name in os.listdir(source_dir):
        full_path = os.path.join(source_dir, dir_name)
        if not os.path.isdir(full_path) or dir_name in ['ThirdParty', 'cmake']:
            continue
        if dir_name == 'WebCore':
            projects.append(Project('PAL', find_source_files('PAL', root_dir, os.path.join(full_path, 'PAL'))))
        sources = find_source_files(dir_name, root_dir, full_path)
        if derived_sources_dir:
            sources += find_source_files(dir_name, os.path.dirname(derived_sources_dir), os.path.join(derived_sources_dir, dir_name))
        projects.append(Project(dir_name, sources))

    project_map = {}
    system_header_map = {}
    for project in projects:
        for source in project.sources():
            system_header_map[source.system_include_path()] = source
        project_map[project.name()] = project

    for project in projects:
        project.resolve_includes(system_header_map)

    result = {'projects': [], 'sources': []}
    for project in projects:
        result['projects'].append(project.to_dict())
        for source in project.sources():
            result['sources'].append(source.to_dict())

    print(json.dumps(result))

    return

    for project in projects:
        project.compute_include_origins()

    for project in projects:
        print('====================', project.name(), '====================')
        for source in sorted(project.sources(), key=lambda source: source.total_include_count(), reverse=True):
            if not source.total_include_count():
                continue
            print(source.path(), 'included by', source.total_include_count(), 'files')


def find_source_files(project, root_dir, dir_path):
    source_files = []
    for dirpath, dirnames, filenames in os.walk(dir_path):
        for file_name in filenames:
            file_path = os.path.join(dirpath, file_name)
            _, ext = os.path.splitext(file_path)
            if os.path.relpath(os.path.dirname(file_path), dir_path) == 'PAL':
                continue
            if ext not in ['.c', '.cpp', '.m', '.mm', '.h']:
                continue
            with open(file_path) as source_file:
                system_includes = []
                local_includes = []
                for line in source_file:
                    include_match = SYSTEM_HEADER_INCLUDE_PATTERN_REGEX.match(line)
                    if include_match:
                        system_includes.append(include_match.group('include'))
                    include_match = LOCAL_HEADER_INCLUDE_PATTERN_REGEX.match(line)
                    if include_match:
                        local_includes.append(include_match.group('include'))
                rel_path = os.path.relpath(file_path, dir_path) if project in ['WTF', 'PAL'] else file_name
                rel_path_to_root = os.path.relpath(file_path, root_dir)
                source_files.append(SourceFile(project, rel_path, rel_path_to_root, file_path, system_includes, local_includes))
    return source_files


class Project(object):
    def __init__(self, name, sources):
        self._name = name
        self._sources = sources
        self._source_map = {}
        for source in sources:
            if name == 'WTF' and source.local_include_path().startswith('icu/unicode/'):
                self._source_map[source.local_include_path().removeprefix('icu/')] = source
            else:
                self._source_map[source.local_include_path()] = source

    def to_dict(self):
        return {'name': self._name, 'sources': [source.path() for source in self._sources]}

    def name(self):
        return self._name

    def sources(self):
        return self._sources

    def resolve_includes(self, system_header_map):
        for source in self._sources:
            source.resolve_local_includes(self._source_map)
            source.resolve_system_includes(system_header_map)

    def compute_include_origins(self):
        for source in self._sources:
            if source.is_included_by_other_sources():
                continue
            includes = compute_all_includes(source)
            for target in includes:
                target.add_total_include_count()


def compute_all_includes(source, targets=set(), working_set=set()):
    if source in working_set:
        return targets; # Detected a cycle.
    for included_source in source.includes():
        if included_source in targets:
            continue
        targets.add(included_source)
        compute_all_includes(included_source, targets, set(list(working_set) + [source]))
    return targets


class SourceFile(object):
    def __init__(self, project, rel_path, rel_path_to_root, file_path, system_include_paths, local_include_paths):
        self._project = project
        self._rel_path = rel_path
        self._rel_path_to_root = rel_path_to_root
        self._file_path = file_path
        self._system_include_paths = system_include_paths
        self._system_includes = []
        self._local_include_paths = local_include_paths
        self._local_includes = []
        self._include_origins = []
        self._transitive_include_count = None
        self._total_include_count = 0
        self._not_found = []

    def to_dict(self):
        return {
            'project': self._project,
            'name': self.local_include_path(),
            'relative': self._rel_path_to_root,
            'path': self.path(),
            'includes': [source.path() for source in self.includes()],
            'notFound': self._not_found,
        }

    def project(self):
        return self._project

    def path(self):
        return self._file_path

    def local_include_path(self):
        return self._rel_path

    def system_include_path(self):
        if self._project in ['WTF', 'PAL']:
            return self._rel_path
        return os.path.join(self._project, self._rel_path)

    def resolve_local_includes(self, source_map):
        for path in self._local_include_paths:
            target_source = source_map.get(path)
            if target_source:
                target_source.add_include_origin(self)
                self._local_includes.append(target_source)
            else:
                self._not_found.append(path)

    def resolve_system_includes(self, system_header_map):
        for path in self._system_include_paths:
            target_source = system_header_map.get(path)
            if target_source:
                target_source.add_include_origin(self)
                self._system_includes.append(target_source)
            else:
                self._not_found.append(path)

    def add_total_include_count(self):
        self._total_include_count += 1

    def total_include_count(self):
        return self._total_include_count

    def add_include_origin(self, source):
        self._include_origins.append(source)

    def is_included_by_other_sources(self):
        return len(self._include_origins)

    def compute_include_count(self, current_path=[]):
        if current_path.count(self):
            print('Detected a cycle!', [source.path() for source in current_path] + [self.path()])
            return 0
        if self._transitive_include_count is None:
            count = 1
            for origin in self._include_origins:
                count += origin.compute_include_count(current_path + [self])
            self._transitive_include_count = count
            print('transitive count:', count, 'origins:', len(self._include_origins), self.path())
        return self._transitive_include_count

    def includes(self):
        return self._system_includes + self._local_includes

    def not_found(self):
        return self._not_found


if __name__ == '__main__':
    main()