#!/usr/bin/env python3
# Copyright 2025 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import unittest
import os
import tempfile
import shutil

import bedrock_metrics


class TestBedrockMetrics(unittest.TestCase):

  def setUp(self):
    # Create a temporary directory for test files.
    self.test_dir = tempfile.mkdtemp(prefix="bedrock_test_")
    self.sub_dir = os.path.join(self.test_dir, "sub")
    os.makedirs(self.sub_dir)

    # --- Files for count_matching_files ---
    # Structure:
    # self.test_dir/
    #   - file_alpha.h (Content: "apple banana\ncount_me_once")
    #   - file_beta.cc (Content: "banana cherry\ncount_me_once\ncount_me_once")
    #   - file_gamma.mm (Content: "apple cherry\nno_count_string")
    #   - sub/
    #     - file_delta.h (Content: "apple\ncount_me_once")
    #   - file_exclude_me.cc (Content: "apple banana\ncontent for exclude")
    #   - other_extension.txt (Content: "apple banana\ntext file content")
    #   - empty_file.h (Content: "")
    files_to_create_for_matching = [
        ("file_alpha.h", "apple banana\ncount_me_once"),
        ("file_beta.cc", "banana cherry\ncount_me_once\ncount_me_once"),
        ("file_gamma.mm", "apple cherry\nno_count_string"),
        (os.path.join("sub", "file_delta.h"), "apple\ncount_me_once"),
        ("file_exclude_me.cc", "apple banana\ncontent for exclude"),
        ("other_extension.txt",
         "apple banana\ntext file content"),  # Invalid extension
        ("empty_file.h", "")
    ]

    for rel_path, content in files_to_create_for_matching:
      full_path = os.path.join(self.test_dir, rel_path)
      os.makedirs(os.path.dirname(full_path), exist_ok=True)
      with open(full_path, 'w', encoding='utf-8') as f:
        f.write(content)

    # --- Files for count_lines ---
    self.lines_file1_path = os.path.join(self.test_dir, "lines_file1.data")
    with open(self.lines_file1_path, 'w', encoding='utf-8') as f:
      f.write("line1\nline2\nline3")  # 3 lines

    self.lines_file2_path = os.path.join(self.test_dir, "lines_file2.data")
    with open(self.lines_file2_path, 'w', encoding='utf-8') as f:
      f.write("single line")  # 1 line

    self.lines_empty_file_path = os.path.join(self.test_dir, "lines_empty.data")
    with open(self.lines_empty_file_path, 'w', encoding='utf-8') as f:
      f.write("")  # 0 lines

  def tearDown(self):
    # Remove the temporary directory and its contents after tests.
    shutil.rmtree(self.test_dir)

  # --- Tests for count_matching_files ---

  def test_cmf_no_filters_counts_valid_extensions(self):
    # Expected: file_alpha.h, file_beta.cc, file_gamma.mm, sub/file_delta.h,
    # file_exclude_me.cc, empty_file.h (6 files with .h, .cc, .mm)
    # other_extension.txt is ignored due to extension.
    # No content_match_strings, so string_matches_count is 0.
    count, str_count = bedrock_metrics.count_matching_files(self.test_dir)
    self.assertEqual(count, 6, "File count mismatch with no filters")
    self.assertEqual(str_count, 0,
                     "String count should be 0 with no content search strings")

  def test_cmf_include_filename_single(self):
    # include_filename_strings=["alpha"] -> matches file_alpha.h
    count, str_count = bedrock_metrics.count_matching_files(
        self.test_dir, include_filename_strings=["alpha"])
    self.assertEqual(count, 1)
    self.assertEqual(str_count, 0)

  def test_cmf_include_filename_multiple_all_match(self):
    # include_filename_strings=["file", "alpha"] -> matches file_alpha.h
    count, str_count = bedrock_metrics.count_matching_files(
        self.test_dir, include_filename_strings=["file", "alpha"])
    self.assertEqual(count, 1)
    self.assertEqual(str_count, 0)

  def test_cmf_include_filename_multiple_one_no_match(self):
    # include_filename_strings=["alpha", "beta"] -> No file has BOTH "alpha"
    # AND"beta".
    count, str_count = bedrock_metrics.count_matching_files(
        self.test_dir, include_filename_strings=["alpha", "nomatch"])
    self.assertEqual(count, 0)
    self.assertEqual(str_count, 0)

  def test_cmf_exclude_filename_single(self):
    # exclude_filename_strings=["exclude"] -> Excludes file_exclude_me.cc
    # Original 6 valid files - 1 = 5 files.
    count, str_count = bedrock_metrics.count_matching_files(
        self.test_dir, exclude_filename_strings=["exclude"])
    self.assertEqual(count, 5)
    self.assertEqual(str_count, 0)

  # These tests verify the current code behavior (ANY).
  def test_cmf_include_file_content_strings_any_behavior_one_present(self):
    # include_file_content_strings=["apple"]
    # Matches: file_alpha.h, file_gamma.mm, sub/file_delta.h, file_exclude_me.cc
    # (4 files)
    # file_beta.cc (banana cherry) does not contain "apple". empty_file.h is
    # empty.
    count, str_count = bedrock_metrics.count_matching_files(
        self.test_dir, include_file_content_strings=["apple"])
    self.assertEqual(count, 4)
    self.assertEqual(str_count, 0)

  def test_cmf_include_file_content_strings_any_behavior_multiple_options(self):
    # include_file_content_strings=["apple", "cherry"] (any of these in content)
    # file_alpha.h ("apple") - Yes
    # file_beta.cc ("cherry") - Yes
    # file_gamma.mm ("apple", "cherry") - Yes
    # sub/file_delta.h ("apple") - Yes
    # file_exclude_me.cc ("apple") - Yes
    # empty_file.h - No
    # Expected: 5 files
    count, str_count = bedrock_metrics.count_matching_files(
        self.test_dir, include_file_content_strings=["apple", "cherry"])
    self.assertEqual(count, 5)
    self.assertEqual(str_count, 0)

  def test_cmf_include_file_content_strings_none_present_in_content(self):
    # include_file_content_strings=["nonexistent_string_pattern"]
    count, str_count = bedrock_metrics.count_matching_files(
        self.test_dir,
        include_file_content_strings=["nonexistent_string_pattern"])
    self.assertEqual(count, 0)
    self.assertEqual(str_count, 0)

  def test_cmf_content_match_strings_single_term_count(self):
    # content_match_strings=["count_me_once"]
    # All 6 valid files are checked for content counts.
    # file_alpha.h: 1 | file_beta.cc: 2 | file_gamma.mm: 0
    # sub/file_delta.h: 1 | file_exclude_me.cc: 0 | empty_file.h: 0
    # Total string matches: 1 + 2 + 0 + 1 + 0 + 0 = 4
    count, str_count = bedrock_metrics.count_matching_files(
        self.test_dir, content_match_strings=["count_me_once"])
    self.assertEqual(
        count, 6,
        "File count should include all valid files for content counting")
    self.assertEqual(str_count, 4, "String match count error")

  def test_cmf_content_match_strings_multiple_terms_count(self):
    # content_match_strings=["apple", "banana"]
    # All 6 valid files are checked.
    # file_alpha.h ("apple banana"): apple(1)+banana(1)=2
    # file_beta.cc ("banana cherry"): apple(0)+banana(1)=1
    # file_gamma.mm ("apple cherry"): apple(1)+banana(0)=1
    # sub/file_delta.h ("apple"): apple(1)+banana(0)=1
    # file_exclude_me.cc ("apple banana"): apple(1)+banana(1)=2
    # empty_file.h: apple(0)+banana(0)=0
    # Total string matches: 2+1+1+1+2+0 = 7
    count, str_count = bedrock_metrics.count_matching_files(
        self.test_dir, content_match_strings=["apple", "banana"])
    self.assertEqual(count, 6)
    self.assertEqual(str_count, 7)

  def test_cmf_all_filters_combined(self):
    # include_filename_strings=["file"], exclude_filename_strings=["exclude"]
    # include_file_content_strings=["apple"] (content filter, using 'any' logic
    # of code)
    # content_match_strings=["count_me_once"]

    # 1. Include "file": file_alpha.h, file_beta.cc, file_gamma.mm,
    #    file_exclude_me.cc, empty_file.h
    # 2. Exclude "exclude": Removes file_exclude_me.cc.
    #    Remaining: file_alpha.h, file_beta.cc, file_gamma.mm, empty_file.h
    # 3. include_file_content_strings=["apple"]: (file must contain "apple")
    #    file_alpha.h (has "apple") - Keep
    #    file_beta.cc (no "apple") - Remove
    #    file_gamma.mm (has "apple") - Keep
    #    sub/file_delta.h (has "apple"): - Keep
    #    empty_file.h (no "apple") - Remove
    #    Matched files: file_alpha.h, file_gamma.mm. So, count = 2.
    # 4. content_match_strings=["count_me_once"] on these 2 files:
    #    file_alpha.h: 1 occurrence
    #    file_gamma.mm: 0 occurrences
    #    sub/file_delta.h (has "apple"): 1 occurrences
    #    Total str_count = 1.
    count, str_count = bedrock_metrics.count_matching_files(
        self.test_dir,
        include_file_content_strings=["apple"],
        content_match_strings=["count_me_once"],
        include_filename_strings=["file"],
        exclude_filename_strings=["exclude"])
    self.assertEqual(count, 3)
    self.assertEqual(str_count, 2)

  def test_cmf_empty_directory(self):
    empty_subdir_path = os.path.join(self.test_dir, "empty_subdir_for_test")
    os.makedirs(empty_subdir_path)
    count, str_count = bedrock_metrics.count_matching_files(empty_subdir_path)
    self.assertEqual(count, 0)
    self.assertEqual(str_count, 0)

  def test_cmf_no_matching_extension_files_present(self):
    # Directory with only a .txt file, which is not in [.h, .cc, .mm]
    other_ext_dir = os.path.join(self.test_dir, "other_ext_dir")
    os.makedirs(other_ext_dir)
    with open(os.path.join(other_ext_dir, "somefile.txt"), 'w') as f:
      f.write("content")
    count, str_count = bedrock_metrics.count_matching_files(other_ext_dir)
    self.assertEqual(count, 0)
    self.assertEqual(str_count, 0)

  def test_cmf_include_file_content_strings_is_empty_list(self):
    # An empty list for include_file_content_strings means the content filter
    # (Step 4) is skipped.
    # Same as include_file_content_strings=None.
    count, str_count = bedrock_metrics.count_matching_files(
        self.test_dir, include_file_content_strings=[])
    self.assertEqual(count, 6)  # All 6 valid extension files
    self.assertEqual(str_count, 0)

  def test_cmf_content_match_strings_is_empty_list(self):
    # No strings to count, so str_count should be 0.
    # File count reflects all files matching other criteria.
    count, str_count = bedrock_metrics.count_matching_files(
        self.test_dir, content_match_strings=[])
    self.assertEqual(count, 6)  # All 6 valid extension files
    self.assertEqual(str_count, 0)

  def test_cmf_content_match_strings_includes_empty_string(self):
    # The code `if s_str:` skips empty strings in content_match_strings.
    # So, ["count_me_once", ""] should behave like ["count_me_once"].
    count, str_count = bedrock_metrics.count_matching_files(
        self.test_dir, content_match_strings=["count_me_once", ""])
    self.assertEqual(count, 6)
    self.assertEqual(str_count, 4)  # Same as just ["count_me_once"]

  # --- Tests for count_lines ---

  def test_cl_single_file_multiple_lines(self):
    self.assertEqual(bedrock_metrics.count_lines([self.lines_file1_path]), 3)

  def test_cl_single_file_one_line_no_trailing_newline(self):
    self.assertEqual(bedrock_metrics.count_lines([self.lines_file2_path]), 1)

  def test_cl_multiple_files(self):
    total_lines = bedrock_metrics.count_lines(
        [self.lines_file1_path, self.lines_file2_path])
    self.assertEqual(total_lines, 3 + 1)  # 4

  def test_cl_empty_file(self):
    # An empty file has 0 lines according to file.readlines().
    self.assertEqual(bedrock_metrics.count_lines([self.lines_empty_file_path]),
                     0)

  def test_cl_mixed_files_including_empty(self):
    total_lines = bedrock_metrics.count_lines([
        self.lines_file1_path, self.lines_empty_file_path, self.lines_file2_path
    ])
    self.assertEqual(total_lines, 3 + 0 + 1)  # 4

  def test_cl_empty_file_list(self):
    self.assertEqual(bedrock_metrics.count_lines([]), 0)


if __name__ == '__main__':
  unittest.main(verbosity=2)