Test script for creating releases with comprehensive changes (development only)

create_test_releases.rb

# frozen_string_literal: true

# Run this in Rails console (development only):
#   load 'lib/scripts/create_test_releases.rb'
#
# This creates:
# - Release 1: Base release with multiple resources
# - Release 2: Regular release with adds, modifies, removes
# - Test Release: Based on Release 1 with adds, modifies, removes

module CreateTestReleases
  extend self

  def run!
    unless Rails.env.development?
      raise "This script can only be run in development environment (current: #{Rails.env})"
    end

    puts "Creating test releases with comprehensive changes..."

    # Use timestamp to make keys unique across runs
    ts = Time.now.to_i

    # Setup
    user = User.find_or_create_by!(email: 'test@example.com') do |u|
      u.team = 'Test Team'
      u.is_admin = true
    end

    agency = Agency.find_or_create_by!(name: 'Test Agency') do |a|
      a.short_name = 'TA'
      a.state = 'US'
      a.jurisdiction_type = 'state'
    end

    value_type = ValueType.find_or_create_by!(name: 'string')
    format_type = FormatType.find_or_create_by!(name: 'test_format') do |ft|
      ft.value_type = value_type
      ft.truncated = true
      ft.uppercased = false
    end

    # Schedule types for deposit/filing revisions (these are seeded)
    monthly_schedule = ScheduleType.find_by!(name: 'Monthly')
    quarterly_schedule = ScheduleType.find_by!(name: 'Quarterly')
    annual_schedule = ScheduleType.find_by!(name: 'Annual')

    # Schedule behaviors (these are seeded, optional for schedules)
    monthly_behavior = ScheduleBehavior.find_by!(name: 'Monthly - due on the 15th')
    quarterly_behavior = ScheduleBehavior.find_by!(name: 'Quarterly - due on EOM')
    annual_behavior = ScheduleBehavior.find_by!(name: 'Annual - due on Jan 31st')

    # ============================================================
    # Create resources for Release 1 (base release)
    # We create 2 of each type so we can modify one and remove one
    # ============================================================
    puts "\n=== Creating base resources for Release 1 ==="

    base_resources = {}

    # Deposits - with revisions for meaningful diff
    base_resources[:deposits] = 2.times.map do |i|
      deposit = Deposit.create!(key: "Test Deposit #{ts}-#{i + 1}", name: "Test Deposit #{i + 1}", state: 'US', agency: agency)
      DepositVersion.create!(
        deposit: deposit,
        version_name: 'V1',
        draft: true,
        deposit_revisions: [
          DepositRevision.new(
            effective_date: Date.new(2024, 1, 1),
            name: "Original Revision #{i + 1}",
            deposit_schedules: [
              DepositSchedule.new(
                schedule_type: monthly_schedule,
                schedule_behavior: monthly_behavior,
                label: "Monthly Schedule #{i + 1}",
                fallback: true,
                forced: false,
                requires_zero_deposit: false
              )
            ]
          )
        ]
      )
    end
    puts "  Created #{base_resources[:deposits].size} deposits (with revisions)"

    # Filings - with revisions for meaningful diff
    base_resources[:filings] = 2.times.map do |i|
      filing = Filing.create!(key: "Test Filing #{ts}-#{i + 1}", name: "Test Filing #{i + 1}", state: 'US', agency: agency)
      FilingVersion.create!(
        filing: filing,
        version_name: 'V1',
        draft: true,
        filing_revisions: [
          FilingRevision.new(
            effective_date: Date.new(2024, 1, 1),
            name: "Original Filing Revision #{i + 1}",
            requires_zero_return: false,
            requires_collated_w2s: false,
            filing_schedules: [
              FilingSchedule.new(
                schedule_type: quarterly_schedule,
                schedule_behavior: quarterly_behavior,
                label: "Quarterly Schedule #{i + 1}",
                fallback: true,
                forced: false
              )
            ]
          )
        ]
      )
    end
    puts "  Created #{base_resources[:filings].size} filings (with revisions)"

    # CSV Records - with fields for meaningful diff
    base_resources[:csv_records] = 2.times.map do |i|
      csv_record = CsvRecord.create!(key: "Test CSV Record #{ts}-#{i + 1}", name: "Test CSV #{i + 1}", state: 'US')
      CsvRecordVersion.create!(
        csv_record: csv_record,
        version_name: 'V1',
        draft: true,
        csv_record_metadatum: CsvRecordMetadatum.new,
        csv_record_fields: [
          CsvRecordField.new(
            order: 1,
            name: "OriginalField#{i + 1}",
            description: "Original description for field #{i + 1}",
            max_length: 50,
            required: false,
            format: Format.new(format_type: format_type),
            constant_value: ConstantValue.new(value_type: value_type, value: "original#{i}")
          )
        ]
      )
    end
    puts "  Created #{base_resources[:csv_records].size} csv_records (with fields)"

    # Fixed Width Records - length must match column_end of last field
    base_resources[:fixed_width_records] = 2.times.map do |i|
      fw_record = FixedWidthRecord.create!(key: "Test FW Record #{ts}-#{i + 1}", name: "Test FW #{i + 1}", state: 'US')
      field_end = 100 + (i * 10)
      FixedWidthRecordVersion.create!(
        fixed_width_record: fw_record,
        version_name: 'V1',
        draft: true,
        length: field_end, # Must match column_end
        line_ending_str: 'lf',
        fixed_width_record_metadatum: FixedWidthRecordMetadatum.new,
        fixed_width_record_fields: [
          FixedWidthRecordField.new(
            column_start: 1,
            column_end: field_end,
            name: 'Field1',
            format: Format.new(format_type: format_type),
            constant_value: ConstantValue.new(value_type: value_type, value: "val#{i}"),
            required: false
          )
        ]
      )
    end
    puts "  Created #{base_resources[:fixed_width_records].size} fixed_width_records"

    # XML Records - with fields for meaningful diff
    base_resources[:xml_records] = 2.times.map do |i|
      xml_record = XmlRecord.create!(key: "Test XML Record #{ts}-#{i + 1}", name: "Test XML #{i + 1}", state: 'US')
      XmlRecordVersion.create!(
        xml_record: xml_record,
        version_name: 'V1',
        draft: true,
        xml_record_metadatum: XmlRecordMetadatum.new,
        xml_record_fields: [
          XmlRecordField.new(
            order: 1,
            name: "OriginalXmlField#{i + 1}",
            description: "Original XML field description #{i + 1}",
            xpath: "/Root/OriginalElement#{i + 1}",
            min_length: 0,
            max_length: 100,
            required: false,
            format: Format.new(format_type: format_type),
            constant_value: ConstantValue.new(value_type: value_type, value: "xmlval#{i}")
          )
        ]
      )
    end
    puts "  Created #{base_resources[:xml_records].size} xml_records (with fields)"

    # TXP Records
    base_resources[:txp_records] = 2.times.map do |i|
      txp_record = TxpRecord.create!(key: "Test TXP Record #{ts}-#{i + 1}", name: "Test TXP #{i + 1}", state: 'US')
      TxpRecordVersion.create!(
        txp_record: txp_record,
        version_name: 'V1',
        draft: true,
        segment_identifier_str: 'TXP',
        has_trailing_separator: false,
        txp_record_metadatum: TxpRecordMetadatum.new
      )
    end
    puts "  Created #{base_resources[:txp_records].size} txp_records"

    # PDF Records (need PDF template) - with fields for meaningful diff
    base_resources[:pdf_records] = 2.times.map do |i|
      pdf_record = PdfRecord.create!(key: "Test PDF Record #{ts}-#{i + 1}", name: "Test PDF #{i + 1}", state: 'US')
      pdf_template = PdfTemplate.new
      # Create a minimal valid PDF
      pdf_content = "%PDF-1.4\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1>>endobj\n3 0 obj<</Type/Page/MediaBox[0 0 612 792]/Parent 2 0 R>>endobj\nxref\n0 4\n0000000000 65535 f\n0000000009 00000 n\n0000000058 00000 n\n0000000115 00000 n\ntrailer<</Size 4/Root 1 0 R>>\nstartxref\n193\n%%EOF"
      pdf_template.file.attach(io: StringIO.new(pdf_content), filename: "test_#{i + 1}.pdf", content_type: 'application/pdf')
      pdf_template.save!
      PdfRecordVersion.create!(
        pdf_record: pdf_record,
        pdf_template: pdf_template,
        version_name: 'V1',
        draft: true,
        pdf_record_fields: [
          PdfRecordField.new(
            order: 1,
            name: "OriginalPdfField#{i + 1}",
            description: "Original PDF field #{i + 1}",
            kind: DbEnums::PdfRecordFieldKind::Text.serialize,
            page: 1,
            max_length: 50,
            required: false,
            format: Format.new(format_type: format_type),
            constant_value: ConstantValue.new(value_type: value_type, value: "pdfval#{i}")
          )
        ]
      )
    end
    puts "  Created #{base_resources[:pdf_records].size} pdf_records (with fields)"

    # Forms (PDF type with documents that reference the pdf_records)
    base_resources[:forms] = 2.times.map do |i|
      form = Form.create!(key: "Test Form #{ts}-#{i + 1}", name: "Test Form #{i + 1}", state: 'US')
      pdf_record = base_resources[:pdf_records][i].pdf_record
      FormVersion.create!(
        form: form,
        version_name: 'V1',
        type: 'pdf',
        bulk: false,
        draft: true,
        form_revisions: [
          FormRevision.new(
            effective_date: Date.new(2024, 1, 1),
            name: '2024',
            pdf_document: PdfDocument.new(
              pdf_document_records: [
                PdfDocumentRecord.new(pdf_record: pdf_record, order: 0)
              ]
            )
          )
        ]
      )
    end
    puts "  Created #{base_resources[:forms].size} forms (with PDF documents)"

    # EINs
    base_resources[:eins] = 2.times.map do |i|
      ein = Ein.create!(key: "Test EIN #{ts}-#{i + 1}", state: 'US', name: "Test EIN #{i + 1}")
      EinVersion.create!(
        ein: ein,
        version_name: 'V1',
        draft: true,
        label: "EIN Label #{i + 1}",
        description: "Original description for EIN #{i + 1}"
      )
    end
    puts "  Created #{base_resources[:eins].size} eins"

    # Tax Rates - with revisions for meaningful diff
    base_resources[:tax_rates] = 2.times.map do |i|
      tax_rate = TaxRate.create!(key: "Test Tax Rate #{ts}-#{i + 1}", state: 'US', name: "Test Rate #{i + 1}")
      TaxRateVersion.create!(
        tax_rate: tax_rate,
        version_name: 'V1',
        draft: true,
        tax_rate_revisions: [
          TaxRateRevision.new(
            effective_date: Date.new(2024, 1, 1),
            name: "Original Rate Revision #{i + 1}",
            allow_zero: false,
            default: BigDecimal("0.0#{i + 1}"),
            tax_rate_validation: TaxRateValidation.new(
              type: DbEnums::TaxRateValidationType::MinMax.serialize,
              data: { min: 0.001, max: 0.1 }
            )
          )
        ]
      )
    end
    puts "  Created #{base_resources[:tax_rates].size} tax_rates (with revisions)"

    # Taxes (need at least 1 reporting parameter)
    base_resources[:taxes] = 2.times.map do |i|
      tax = Tax.create!(key: "00-000-#{ts}#{i}-ER_TEST-00#{i}", ste_id: "00-000-#{ts}#{i}-ER_TEST-00#{i}")
      TaxVersion.create!(
        tax: tax,
        version_name: 'V1',
        draft: true,
        tax_name: "Test Tax #{i + 1}",
        tax_short_name: "TT#{i + 1}",
        payable: true,
        reporting_parameters: [ReportingParameter.new(key: DbEnums::ReportingParameterType::Blank.serialize)]
      )
    end
    puts "  Created #{base_resources[:taxes].size} taxes"

    # ============================================================
    # Create Release 1 with all base resources
    # ============================================================
    puts "\n=== Creating Release 1 ==="

    release1_input = Releases::Creator::Input.new(
      deposit_ids_to_add: base_resources[:deposits].map(&:id),
      filing_ids_to_add: base_resources[:filings].map(&:id),
      form_ids_to_add: base_resources[:forms].map(&:id),
      csv_record_ids_to_add: base_resources[:csv_records].map(&:id),
      fixed_width_record_ids_to_add: base_resources[:fixed_width_records].map(&:id),
      xml_record_ids_to_add: base_resources[:xml_records].map(&:id),
      txp_record_ids_to_add: base_resources[:txp_records].map(&:id),
      pdf_record_ids_to_add: base_resources[:pdf_records].map(&:id),
      ein_ids_to_add: base_resources[:eins].map(&:id),
      tax_rate_ids_to_add: base_resources[:tax_rates].map(&:id),
      tax_ids_to_add: base_resources[:taxes].map(&:id),
      user: user
    )

    release1 = Releases::Creator.create!(release1_input)
    ReleaseDataBuilderWorker.new.perform(release1.id)
    puts "  Created Release #{release1.version}"

    # ============================================================
    # Create NON-VERSIONED resources (for diff between releases)
    # These are created AFTER Release 1 and BEFORE Release 2
    # ============================================================
    puts "\n=== Creating non-versioned resources (will appear as 'added' in Release 2) ==="

    # New DataFieldContext
    new_context = DataFieldContext.create!(
      name: "Test Context #{ts}",
      description: "Context created after Release 1"
    )
    puts "  Created DataFieldContext: #{new_context.name}"

    # New DataFields
    3.times do |i|
      DataField.create!(
        name: "TestField#{ts}_#{i + 1}",
        description: "Test field #{i + 1} created after Release 1",
        example: "example#{i + 1}",
        data_field_context: new_context,
        value_type: value_type,
        deprecated: false
      )
    end
    puts "  Created 3 DataFields"

    # New ValueType
    new_value_type = ValueType.create!(
      name: "test_value_type_#{ts}",
      description: "Value type created after Release 1"
    )
    puts "  Created ValueType: #{new_value_type.name}"

    # New FormatType
    new_format_type = FormatType.create!(
      name: "test_format_type_#{ts}",
      value_type: new_value_type,
      truncated: false,
      uppercased: true,
      description: "Format type created after Release 1"
    )
    puts "  Created FormatType: #{new_format_type.name}"

    # New FormatPadding
    new_padding = FormatPadding.create!(
      name: "test_padding_#{ts}",
      description: "Padding created after Release 1"
    )
    puts "  Created FormatPadding: #{new_padding.name}"

    # New ScheduleBehavior
    new_schedule_behavior = ScheduleBehavior.create!(
      name: "Test Behavior #{ts}",
      description: "Schedule behavior created after Release 1"
    )
    puts "  Created ScheduleBehavior: #{new_schedule_behavior.name}"

    # New ScheduleType
    new_schedule_type = ScheduleType.create!(
      name: "Test Schedule #{ts}",
      description: "Schedule type created after Release 1",
      default_label: "Test Label",
      default_behavior: new_schedule_behavior
    )
    puts "  Created ScheduleType: #{new_schedule_type.name}"

    # New DepositCalculator
    new_deposit_calculator = DepositCalculator.create!(
      name: "test_deposit_calc_#{ts}",
      description: "Deposit calculator created after Release 1"
    )
    puts "  Created DepositCalculator: #{new_deposit_calculator.name}"

    # New FilingCalculator
    new_filing_calculator = FilingCalculator.create!(
      name: "test_filing_calc_#{ts}",
      description: "Filing calculator created after Release 1"
    )
    puts "  Created FilingCalculator: #{new_filing_calculator.name}"

    # New Agency (will appear as 'added' in agencies list)
    new_agency = Agency.create!(
      name: "New Test Agency #{ts}",
      short_name: "NTA#{ts}",
      state: 'CA',
      jurisdiction_type: 'state',
      description: "Agency created after Release 1"
    )
    puts "  Created Agency: #{new_agency.name}"

    puts "  Non-versioned resources will appear as 'added' in Release 2 diff"

    # ============================================================
    # Create NEW resources (for "added" in Release 2)
    # ============================================================
    puts "\n=== Creating new versioned resources to ADD in Release 2 ==="

    new_resources = {}

    # New Deposit (linked to new_agency so agency shows deposits in Release 2)
    new_deposit = Deposit.create!(key: "New Deposit #{ts}", name: "New Deposit", state: 'CA', agency: new_agency)
    new_resources[:deposit] = DepositVersion.create!(deposit: new_deposit, version_name: 'V1', draft: true, deposit_revisions: [])

    # New Filing (linked to new_agency so agency shows filings in Release 2)
    new_filing = Filing.create!(key: "New Filing #{ts}", name: "New Filing", state: 'CA', agency: new_agency)
    new_resources[:filing] = FilingVersion.create!(filing: new_filing, version_name: 'V1', draft: true, filing_revisions: [])

    # New CSV Record (create before form so form can reference it)
    new_csv = CsvRecord.create!(key: "New CSV Record #{ts}", name: "New CSV", state: 'CA')
    new_resources[:csv_record] = CsvRecordVersion.create!(csv_record: new_csv, version_name: 'V1', draft: true, csv_record_metadatum: CsvRecordMetadatum.new)

    # New Form (CSV type with document)
    new_form = Form.create!(key: "New Form #{ts}", name: "New Form", state: 'CA')
    new_resources[:form] = FormVersion.create!(
      form: new_form,
      version_name: 'V1',
      type: 'csv',
      bulk: true,
      draft: true,
      form_revisions: [
        FormRevision.new(
          effective_date: Date.new(2024, 1, 1),
          name: '2024',
          csv_document: CsvDocument.new(
            csv_document_records: [
              CsvDocumentRecord.new(csv_record: new_csv, order: 0, type: DbEnums::DocumentRecordType::Company.serialize)
            ]
          )
        )
      ]
    )

    # New Fixed Width Record - length must match column_end
    new_fw = FixedWidthRecord.create!(key: "New FW Record #{ts}", name: "New FW", state: 'CA')
    new_resources[:fixed_width_record] = FixedWidthRecordVersion.create!(
      fixed_width_record: new_fw,
      version_name: 'V1',
      draft: true,
      length: 200,
      line_ending_str: 'cr_lf',
      fixed_width_record_metadatum: FixedWidthRecordMetadatum.new,
      fixed_width_record_fields: [
        FixedWidthRecordField.new(
          column_start: 1, column_end: 200, name: 'NewField',
          format: Format.new(format_type: format_type),
          constant_value: ConstantValue.new(value_type: value_type, value: 'new'),
          required: true
        )
      ]
    )

    # New XML Record
    new_xml = XmlRecord.create!(key: "New XML Record #{ts}", name: "New XML", state: 'CA')
    new_resources[:xml_record] = XmlRecordVersion.create!(xml_record: new_xml, version_name: 'V1', draft: true, xml_record_metadatum: XmlRecordMetadatum.new)

    # New TXP Record
    new_txp = TxpRecord.create!(key: "New TXP Record #{ts}", name: "New TXP", state: 'CA')
    new_resources[:txp_record] = TxpRecordVersion.create!(
      txp_record: new_txp, version_name: 'V1', draft: true,
      segment_identifier_str: 'NEW', has_trailing_separator: true,
      txp_record_metadatum: TxpRecordMetadatum.new
    )

    # New PDF Record
    new_pdf = PdfRecord.create!(key: "New PDF Record #{ts}", name: "New PDF", state: 'CA')
    new_pdf_template = PdfTemplate.new
    pdf_content = "%PDF-1.4\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1>>endobj\n3 0 obj<</Type/Page/MediaBox[0 0 612 792]/Parent 2 0 R>>endobj\nxref\n0 4\n0000000000 65535 f\n0000000009 00000 n\n0000000058 00000 n\n0000000115 00000 n\ntrailer<</Size 4/Root 1 0 R>>\nstartxref\n193\n%%EOF"
    new_pdf_template.file.attach(io: StringIO.new(pdf_content), filename: "new.pdf", content_type: 'application/pdf')
    new_pdf_template.save!
    new_resources[:pdf_record] = PdfRecordVersion.create!(pdf_record: new_pdf, pdf_template: new_pdf_template, version_name: 'V1', draft: true, pdf_record_fields: [])

    # New EIN
    new_ein = Ein.create!(key: "New EIN #{ts}", state: 'CA', name: "New EIN")
    new_resources[:ein] = EinVersion.create!(ein: new_ein, version_name: 'V1', draft: true, label: "New EIN Label", description: "Brand new EIN")

    # New Tax Rate
    new_tax_rate = TaxRate.create!(key: "New Tax Rate #{ts}", state: 'CA', name: "New Rate")
    new_resources[:tax_rate] = TaxRateVersion.create!(tax_rate: new_tax_rate, version_name: 'V1', draft: true)

    # New Tax (need reporting parameter)
    new_tax = Tax.create!(key: "00-000-#{ts}-ER_NEW-999", ste_id: "00-000-#{ts}-ER_NEW-999")
    new_resources[:tax] = TaxVersion.create!(
      tax: new_tax,
      version_name: 'V1',
      draft: true,
      tax_name: "New Tax",
      tax_short_name: "NT",
      payable: false,
      reporting_parameters: [ReportingParameter.new(key: DbEnums::ReportingParameterType::Blank.serialize)]
    )

    puts "  Created #{new_resources.size} new versioned resources"

    # ============================================================
    # Create MODIFIED versions (new version of first resource of each type)
    # All modified versions now have meaningful changes that show in JSON diff
    # ============================================================
    puts "\n=== Creating modified versions for Release 2 ==="

    modified_versions = {}

    # Modified Deposit - change revision name and schedule properties
    original_deposit = base_resources[:deposits][0]
    modified_versions[:deposit] = DepositVersion.create!(
      deposit: original_deposit.deposit,
      version_name: 'V2 - MODIFIED',
      draft: true,
      deposit_revisions: [
        DepositRevision.new(
          effective_date: Date.new(2024, 1, 1),
          name: "MODIFIED Revision", # Changed name
          deposit_schedules: [
            DepositSchedule.new(
              schedule_type: quarterly_schedule, # Changed from monthly
              schedule_behavior: quarterly_behavior, # Changed behavior
              label: "Quarterly Schedule - MODIFIED", # Changed label
              fallback: false, # Changed from true
              forced: true, # Changed from false
              requires_zero_deposit: true # Changed from false
            )
          ]
        )
      ]
    )

    # Modified Filing - change revision properties
    original_filing = base_resources[:filings][0]
    modified_versions[:filing] = FilingVersion.create!(
      filing: original_filing.filing,
      version_name: 'V2 - MODIFIED',
      draft: true,
      filing_revisions: [
        FilingRevision.new(
          effective_date: Date.new(2024, 1, 1),
          name: "MODIFIED Filing Revision", # Changed name
          requires_zero_return: true, # Changed from false
          requires_collated_w2s: true, # Changed from false (allowed with annual)
          filing_schedules: [
            FilingSchedule.new(
              schedule_type: annual_schedule, # Changed from quarterly
              schedule_behavior: annual_behavior, # Changed behavior
              label: "Annual Schedule - MODIFIED", # Changed label
              fallback: false, # Changed from true
              forced: true # Changed from false
            )
          ]
        )
      ]
    )

    # Modified Form - change bulk flag AND change document to use different pdf_record
    original_form = base_resources[:forms][0]
    # Use the second pdf_record instead of the first (document change)
    different_pdf_record = base_resources[:pdf_records][1].pdf_record
    modified_versions[:form] = FormVersion.create!(
      form: original_form.form,
      version_name: 'V2 - MODIFIED',
      type: 'pdf',
      bulk: true, # Changed from false to true
      draft: true,
      form_revisions: [
        FormRevision.new(
          effective_date: Date.new(2024, 1, 1),
          name: '2024',
          pdf_document: PdfDocument.new(
            pdf_document_records: [
              PdfDocumentRecord.new(pdf_record: different_pdf_record, order: 0) # Different record!
            ]
          )
        )
      ]
    )

    # Modified CSV Record - change field properties
    original_csv = base_resources[:csv_records][0]
    modified_versions[:csv_record] = CsvRecordVersion.create!(
      csv_record: original_csv.csv_record,
      version_name: 'V2 - MODIFIED',
      draft: true,
      csv_record_metadatum: CsvRecordMetadatum.new,
      csv_record_fields: [
        CsvRecordField.new(
          order: 1,
          name: "ModifiedField", # Changed name
          description: "MODIFIED description with new content", # Changed description
          max_length: 100, # Changed from 50
          required: true, # Changed from false
          format: Format.new(format_type: format_type),
          constant_value: ConstantValue.new(value_type: value_type, value: "modified_value") # Changed value
        ),
        CsvRecordField.new( # Added a second field
          order: 2,
          name: "NewlyAddedField",
          description: "This field was added in the modified version",
          max_length: 25,
          required: false,
          format: Format.new(format_type: format_type),
          constant_value: ConstantValue.new(value_type: value_type, value: "new")
        )
      ]
    )

    # Modified Fixed Width Record - change length and line_ending
    original_fw = base_resources[:fixed_width_records][0]
    modified_versions[:fixed_width_record] = FixedWidthRecordVersion.create!(
      fixed_width_record: original_fw.fixed_width_record,
      version_name: 'V2 - MODIFIED',
      draft: true,
      length: 150, # Changed from 100
      line_ending_str: 'cr_lf', # Changed from 'lf'
      fixed_width_record_metadatum: FixedWidthRecordMetadatum.new,
      fixed_width_record_fields: [
        FixedWidthRecordField.new(
          column_start: 1, column_end: 150, # Must match length
          name: 'ModifiedField', # Changed name
          format: Format.new(format_type: format_type),
          constant_value: ConstantValue.new(value_type: value_type, value: 'modified'),
          required: true # Changed from false
        )
      ]
    )

    # Modified XML Record - change field properties
    original_xml = base_resources[:xml_records][0]
    modified_versions[:xml_record] = XmlRecordVersion.create!(
      xml_record: original_xml.xml_record,
      version_name: 'V2 - MODIFIED',
      draft: true,
      xml_record_metadatum: XmlRecordMetadatum.new,
      xml_record_fields: [
        XmlRecordField.new(
          order: 1,
          name: "ModifiedXmlField", # Changed name
          description: "MODIFIED XML field description", # Changed description
          xpath: "/Root/ModifiedElement", # Changed xpath
          min_length: 5, # Changed from 0
          max_length: 200, # Changed from 100
          required: true, # Changed from false
          format: Format.new(format_type: format_type),
          constant_value: ConstantValue.new(value_type: value_type, value: "modified_xml_value") # Changed value
        )
      ]
    )

    # Modified TXP Record - change segment_identifier
    original_txp = base_resources[:txp_records][0]
    modified_versions[:txp_record] = TxpRecordVersion.create!(
      txp_record: original_txp.txp_record,
      version_name: 'V2 - MODIFIED',
      draft: true,
      segment_identifier_str: 'MOD', # Changed from 'TXP'
      has_trailing_separator: true, # Changed from false
      txp_record_metadatum: TxpRecordMetadatum.new
    )

    # Modified PDF Record - change field properties
    original_pdf = base_resources[:pdf_records][0]
    mod_pdf_template = PdfTemplate.new
    mod_pdf_template.file.attach(io: StringIO.new(pdf_content), filename: "modified.pdf", content_type: 'application/pdf')
    mod_pdf_template.save!
    modified_versions[:pdf_record] = PdfRecordVersion.create!(
      pdf_record: original_pdf.pdf_record,
      pdf_template: mod_pdf_template,
      version_name: 'V2 - MODIFIED',
      draft: true,
      pdf_record_fields: [
        PdfRecordField.new(
          order: 1,
          name: "ModifiedPdfField", # Changed name
          description: "MODIFIED PDF field description", # Changed description
          kind: DbEnums::PdfRecordFieldKind::Boolean.serialize, # Changed from Text
          page: 1,
          max_length: 100, # Changed from 50
          required: true, # Changed from false
          format: Format.new(format_type: format_type),
          constant_value: ConstantValue.new(value_type: value_type, value: "modified_pdf_value") # Changed value
        )
      ]
    )

    # Modified EIN - change description and label
    original_ein = base_resources[:eins][0]
    modified_versions[:ein] = EinVersion.create!(
      ein: original_ein.ein,
      version_name: 'V2 - MODIFIED',
      draft: true,
      label: "Modified EIN Label", # Changed
      description: "Modified description with new content" # Changed
    )

    # Modified Tax Rate - change revision properties
    original_tax_rate = base_resources[:tax_rates][0]
    modified_versions[:tax_rate] = TaxRateVersion.create!(
      tax_rate: original_tax_rate.tax_rate,
      version_name: 'V2 - MODIFIED',
      draft: true,
      tax_rate_revisions: [
        TaxRateRevision.new(
          effective_date: Date.new(2024, 1, 1),
          name: "MODIFIED Rate Revision", # Changed name
          allow_zero: true, # Changed from false
          default: BigDecimal("0.05"), # Changed from 0.01
          tax_rate_validation: TaxRateValidation.new(
            type: DbEnums::TaxRateValidationType::MinMax.serialize,
            data: { min: 0.0, max: 0.2 } # Different validation range, allows 0
          )
        )
      ]
    )

    # Modified Tax - change payable and names
    original_tax = base_resources[:taxes][0]
    modified_versions[:tax] = TaxVersion.create!(
      tax: original_tax.tax,
      version_name: 'V2 - MODIFIED',
      draft: true,
      tax_name: "Modified Test Tax", # Changed
      tax_short_name: "MTT", # Changed
      payable: false, # Changed from true
      reporting_parameters: [
        ReportingParameter.new(key: DbEnums::ReportingParameterType::Blank.serialize),
        ReportingParameter.new(key: DbEnums::ReportingParameterType::CA.serialize) # Added CA Credit Reduction
      ]
    )

    puts "  Created #{modified_versions.size} modified versions"

    # ============================================================
    # Resources to REMOVE (second resource of each type stays in release 1 but not release 2)
    # ============================================================
    puts "\n=== Identifying resources to REMOVE in Release 2 ==="

    removed_versions = {
      deposit: base_resources[:deposits][1],
      filing: base_resources[:filings][1],
      form: base_resources[:forms][1],
      csv_record: base_resources[:csv_records][1],
      fixed_width_record: base_resources[:fixed_width_records][1],
      xml_record: base_resources[:xml_records][1],
      txp_record: base_resources[:txp_records][1],
      pdf_record: base_resources[:pdf_records][1],
      ein: base_resources[:eins][1],
      tax_rate: base_resources[:tax_rates][1],
      tax: base_resources[:taxes][1]
    }
    puts "  Will remove #{removed_versions.size} resources"

    # ============================================================
    # Create Release 2 (regular release with all changes)
    # ============================================================
    puts "\n=== Creating Release 2 (regular release with all changes) ==="

    release2_input = Releases::Creator::Input.new(
      # Add new resources
      deposit_ids_to_add: [new_resources[:deposit].id, modified_versions[:deposit].id],
      filing_ids_to_add: [new_resources[:filing].id, modified_versions[:filing].id],
      form_ids_to_add: [new_resources[:form].id, modified_versions[:form].id],
      csv_record_ids_to_add: [new_resources[:csv_record].id, modified_versions[:csv_record].id],
      fixed_width_record_ids_to_add: [new_resources[:fixed_width_record].id, modified_versions[:fixed_width_record].id],
      xml_record_ids_to_add: [new_resources[:xml_record].id, modified_versions[:xml_record].id],
      txp_record_ids_to_add: [new_resources[:txp_record].id, modified_versions[:txp_record].id],
      pdf_record_ids_to_add: [new_resources[:pdf_record].id, modified_versions[:pdf_record].id],
      ein_ids_to_add: [new_resources[:ein].id, modified_versions[:ein].id],
      tax_rate_ids_to_add: [new_resources[:tax_rate].id, modified_versions[:tax_rate].id],
      tax_ids_to_add: [new_resources[:tax].id, modified_versions[:tax].id],
      # Remove resources
      deposit_ids_to_remove: [removed_versions[:deposit].id],
      filing_ids_to_remove: [removed_versions[:filing].id],
      form_ids_to_remove: [removed_versions[:form].id],
      csv_record_ids_to_remove: [removed_versions[:csv_record].id],
      fixed_width_record_ids_to_remove: [removed_versions[:fixed_width_record].id],
      xml_record_ids_to_remove: [removed_versions[:xml_record].id],
      txp_record_ids_to_remove: [removed_versions[:txp_record].id],
      pdf_record_ids_to_remove: [removed_versions[:pdf_record].id],
      ein_ids_to_remove: [removed_versions[:ein].id],
      tax_rate_ids_to_remove: [removed_versions[:tax_rate].id],
      tax_ids_to_remove: [removed_versions[:tax].id],
      user: user
    )

    release2 = Releases::Creator.create!(release2_input)
    ReleaseDataBuilderWorker.new.perform(release2.id)
    puts "  Created Release #{release2.version}"

    # ============================================================
    # Create Test Release (based on Release 1, with similar changes)
    # We need fresh draft versions for the test release since
    # the previous ones were used in Release 2
    # ============================================================
    puts "\n=== Creating Test Release (based on Release 1) ==="

    # Create fresh versions for test release
    test_new_resources = {}

    # New resources for test release
    test_new_deposit = Deposit.create!(key: "Test New Deposit #{ts}", name: "Test New Deposit", state: 'NY', agency: agency)
    test_new_resources[:deposit] = DepositVersion.create!(deposit: test_new_deposit, version_name: 'V1', draft: true, deposit_revisions: [])

    test_new_form = Form.create!(key: "Test New Form #{ts}", name: "Test New Form", state: 'NY')
    test_new_resources[:form] = FormVersion.create!(form: test_new_form, version_name: 'V1', type: 'xml', bulk: false, draft: true, form_revisions: [])

    test_new_ein = Ein.create!(key: "Test New EIN #{ts}", state: 'NY', name: "Test New EIN")
    test_new_resources[:ein] = EinVersion.create!(ein: test_new_ein, version_name: 'V1', draft: true, label: "Test New Label", description: "Test new description")

    # Build test release
    test_input = Releases::Creator::Input.new(
      deposit_ids_to_add: [test_new_resources[:deposit].id],
      form_ids_to_add: [test_new_resources[:form].id],
      ein_ids_to_add: [test_new_resources[:ein].id],
      deposit_ids_to_remove: [base_resources[:deposits][1].id],
      form_ids_to_remove: [base_resources[:forms][1].id],
      ein_ids_to_remove: [base_resources[:eins][1].id],
      user: user
    )

    built_release = Releases::Creator.build(test_input, release1)

    test_release = TestRelease.new(
      release: release1,
      user: user,
      description: "Comprehensive test release - #{Time.now.strftime('%Y-%m-%d %H:%M')}"
    )

    test_release.file.attach(
      io: StringIO.new(Releases::DataBuilder.call(built_release, release1).to_json),
      filename: 'data.json',
      content_type: 'application/json'
    )
    test_release.save!

    puts "  Created Test Release: #{test_release.id}"

    # ============================================================
    # Summary
    # ============================================================
    puts "\n" + "=" * 60
    puts "SUMMARY"
    puts "=" * 60
    puts "\nReleases created:"
    puts "  - Release #{release1.version}: Base release with all resource types"
    puts "  - Release #{release2.version}: Regular release with adds, modifies, removes"
    puts "  - Test Release: #{test_release.id}"
    puts "\nView URLs:"
    puts "  - Compare releases: /releases/compare?versionA=#{release1.version}&versionB=#{release2.version}"
    puts "  - Test release compare: /releases/test-releases/compare?testReleaseId=#{test_release.id}"
    puts "\nChanges in Release 2 vs Release 1:"
    puts "  - Added: 11 new versioned resources (one per type)"
    puts "  - Modified: 11 versioned resources (with meaningful JSON diffs)"
    puts "  - Removed: 11 versioned resources"
    puts "\nNon-versioned resources added (will show in diff):"
    puts "  - 1 Agency"
    puts "  - 1 DataFieldContext"
    puts "  - 3 DataFields"
    puts "  - 1 ValueType"
    puts "  - 1 FormatType"
    puts "  - 1 FormatPadding"
    puts "  - 1 ScheduleBehavior"
    puts "  - 1 ScheduleType"
    puts "  - 1 DepositCalculator"
    puts "  - 1 FilingCalculator"
    puts "\nModified versioned resources include real changes:"
    puts "  - Deposits: revision name, schedule type/behavior/label, requires_zero_deposit"
    puts "  - Filings: revision name, requires_zero_return, schedule type/behavior/label"
    puts "  - CSV Records: field name/description/max_length/required, added field"
    puts "  - XML Records: field name/description/xpath/min_length/max_length/required"
    puts "  - Fixed Width Records: length, line_ending, field name/required"
    puts "  - TXP Records: segment_identifier, has_trailing_separator"
    puts "  - PDF Records: field name/description/kind/max_length/required"
    puts "  - EINs: label, description"
    puts "  - Tax Rates: revision name, allow_zero, default, validation type"
    puts "  - Taxes: tax_name, tax_short_name, payable, reporting_parameters"
    puts "\nChanges in Test Release vs Release 1:"
    puts "  - Added: 3 resources (deposit, form, ein)"
    puts "  - Removed: 3 resources (deposit, form, ein)"

    {
      release1: release1,
      release2: release2,
      test_release: test_release
    }
  end
end

# Run it
CreateTestReleases.run!