fin_it 0.1.0

data/lib/fin_it/outputs/console_output.rb

@@ -0,0 +1,1528 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module FinIt
+  module Outputs
+    class ConsoleOutput < BaseOutput
+      def generate
+        data = @report.generate
+        currency = data[:currency] || (data[:metadata] ? data[:metadata][:currency] : nil)
+        report_type = data[:report_type] || (data[:metadata] ? data[:metadata][:report_type] : nil)
+
+        # Handle special report types early since they have different structures
+        case report_type
+        when "ScenarioComparison"
+          output_scenario_comparison(data, currency)
+          return nil
+        when "PeriodComparison"
+          output_period_comparison(data, currency)
+          return nil
+        when "CustomSheet"
+          output_custom_sheet(data)
+          return nil
+        end
+
+        # Check if we have multiple periods to display as columns
+        periods_data = options[:periods]
+        if periods_data
+          # Handle hash from period_summary
+          if periods_data.is_a?(Hash) && periods_data[:periods]
+            periods_array = periods_data[:periods]
+          elsif periods_data.is_a?(Array)
+            periods_array = periods_data
+          else
+            periods_array = nil
+          end
+
+          if periods_array && periods_array.length > 1
+            output_periods_as_columns(periods_data, report_type, currency)
+            return nil
+          end
+        end
+
+        puts "=" * 80
+        project_name = data[:project] ? " - #{data[:project].to_s.split('_').map(&:capitalize).join(' ')}" : ""
+        puts "#{report_type.upcase}#{project_name} (#{currency})"
+        puts "Period: #{data[:period][:start]} to #{data[:period][:end]}"
+        puts "=" * 80
+
+        # Handle different report types
+        case report_type
+        when "BalanceSheet"
+          output_balance_sheet(data, currency)
+        when "CashFlowStatement"
+          output_cash_flow_statement(data, currency)
+        else
+          output_income_statement(data, currency)
+        end
+        
+        puts "=" * 80
+        
+        # Add statement comments if present
+        if data[:statement_comments] && data[:statement_comments].any?
+          output_statement_comments(data[:statement_comments])
+        end
+        
+        # Add monthly breakdown if requested (only for income statements)
+        if options[:include_monthly] && report_type != "BalanceSheet"
+          puts "\n"
+          output_monthly_breakdown(data, currency)
+        end
+        
+        # Return the string output if needed
+        nil
+      end
+      
+      # Output multiple periods as columns (e.g., from generate_monthly or period_summary)
+      def output_periods_as_columns(periods_data, report_type, currency)
+        # periods_data can be:
+        # 1. Array of { period: {...}, report: {...} } from generate_monthly
+        # 2. Hash with :periods array from period_summary
+        
+        if periods_data.is_a?(Hash) && periods_data[:periods]
+          # From period_summary
+          periods = periods_data[:periods]
+          frequency = periods_data[:frequency] || :monthly
+        else
+          # From generate_monthly or similar
+          periods = periods_data
+          frequency = :monthly
+        end
+        
+        return if periods.empty?
+        
+        # Format period labels
+        period_labels = periods.map do |p|
+          period = p[:period] || p
+          start_date = period[:start] || period
+          format_period_label(start_date, frequency)
+        end
+        
+        # Determine column width
+        col_width = [15, 100 / (period_labels.length + 1)].max
+        total_width = 40 + (col_width * period_labels.length)
+        header_format = "%-40s" + (" %#{col_width-1}s" * period_labels.length)
+        
+        puts "=" * total_width
+        puts "#{report_type.upcase} - PERIOD COMPARISON (#{currency})"
+        puts "=" * total_width
+        puts header_format % (["Item"] + period_labels)
+        puts "-" * total_width
+        
+        case report_type
+        when "BalanceSheet"
+          output_balance_sheet_periods_columns(periods, header_format, currency, col_width)
+        when "CashFlowStatement"
+          output_cash_flow_statement_periods_columns(periods, header_format, currency, col_width)
+        else
+          output_income_statement_periods_columns(periods, header_format, currency, col_width)
+        end
+        
+        puts "=" * total_width
+      end
+      
+      def format_period_label(date, frequency)
+        date = date[:start] if date.is_a?(Hash) && date[:start]
+        case frequency
+        when :monthly
+          date.strftime("%b %Y")
+        when :quarterly
+          quarter = ((date.month - 1) / 3) + 1
+          "Q#{quarter} #{date.year}"
+        when :annual
+          date.year.to_s
+        when :weekly
+          date.strftime("%b %d, %Y")
+        when :daily
+          date.strftime("%b %d, %Y")
+        else
+          date.strftime("%b %Y")
+        end
+      end
+      
+      private
+      
+      def output_income_statement(data, currency)
+        display_items = data[:display_items] || []
+        
+        # Output display items before income section
+        output_display_items(display_items, :before, :income, currency)
+        
+        # Income section
+        if data[:sections][:income]
+          output_section(data[:sections][:income], currency, "INCOME", show_total: true)
+        end
+        
+        # Output display items after income section
+        output_display_items(display_items, :after, :income, currency)
+        
+        # COGS section (if separate_cogs mode)
+        if data[:sections][:cogs]
+          output_display_items(display_items, :before, :cogs, currency)
+          output_section(data[:sections][:cogs], currency, "COST OF GOODS SOLD", show_total: true)
+          output_display_items(display_items, :after, :cogs, currency)
+          
+          # Gross Margin
+          if data[:sections][:gross_margin]
+            puts "\n"
+            puts "-" * 80
+            gross_margin = data[:sections][:gross_margin][:total] || data[:sections][:gross_margin][:value] || 0
+            puts "%-60s %20s" % ["GROSS MARGIN", format_currency(gross_margin, currency)]
+            
+            # Output display items after gross margin
+            output_display_items(display_items, :after, :gross_margin, currency)
+            # Output display items in column next to gross margin
+            output_display_items_column(display_items, :gross_margin, currency)
+          end
+        end
+        
+        # Expense section (operating expenses)
+        if data[:sections][:expenses]
+          output_display_items(display_items, :before, :expenses, currency)
+          section_label = data[:expense_display_mode] == :separate_cogs ? "OPERATING EXPENSES" : "EXPENSES"
+          output_section(data[:sections][:expenses], currency, section_label, show_total: true)
+          output_display_items(display_items, :after, :expenses, currency)
+        end
+        
+        # Net Income
+        if data[:sections][:net_income]
+          output_display_items(display_items, :before, :net_income, currency)
+          puts "\n"
+          puts "-" * 80
+          net_income = data[:sections][:net_income][:total] || data[:sections][:net_income][:value] || 0
+          puts "%-60s %20s" % ["NET INCOME", format_currency(net_income, currency)]
+          output_display_items(display_items, :after, :net_income, currency)
+        end
+      end
+      
+      def output_display_items(display_items, position_type, section_key, currency)
+        items = display_items.select { |item| item[position_type] == section_key }
+        return if items.empty?
+        
+        # Sort by order
+        items = items.sort_by { |item| item[:order] || 0 }
+        
+        items.each do |item|
+          value_str = format_display_value(item[:value], item[:format], currency)
+          puts "%-60s %20s" % [item[:label], value_str]
+        end
+      end
+      
+      def output_display_items_column(display_items, section_key, currency)
+        items = display_items.select { |item| item[:column] == section_key }
+        return if items.empty?
+        
+        # For single period, column items are displayed on the same line or next line
+        # This is a simplified version - full column support would require two-pass rendering
+        items.each do |item|
+          value_str = format_display_value(item[:value], item[:format], currency)
+          puts "%-60s %20s" % ["  #{item[:label]}", value_str]
+        end
+      end
+      
+      def output_balance_sheet(data, currency)
+        # Assets section
+        if data[:sections][:assets]
+          output_balance_sheet_section(data[:sections][:assets], currency, "ASSETS")
+          
+          # Show asset subtotals
+          if data[:sections][:assets][:current_assets] || data[:sections][:assets][:fixed_assets]
+            puts "\n"
+            puts "-" * 80
+            if data[:sections][:assets][:current_assets]
+              puts "%-60s %20s" % ["Current Assets", format_currency(data[:sections][:assets][:current_assets], currency)]
+            end
+            if data[:sections][:assets][:fixed_assets]
+              puts "%-60s %20s" % ["Fixed Assets", format_currency(data[:sections][:assets][:fixed_assets], currency)]
+            end
+            puts "%-60s %20s" % ["TOTAL ASSETS", format_currency(data[:sections][:assets][:total], currency)]
+          end
+        end
+        
+        # Liabilities section
+        if data[:sections][:liabilities]
+          output_balance_sheet_section(data[:sections][:liabilities], currency, "LIABILITIES")
+          
+          # Show liability subtotals
+          if data[:sections][:liabilities][:current_liabilities] || data[:sections][:liabilities][:long_term_liabilities]
+            puts "\n"
+            puts "-" * 80
+            if data[:sections][:liabilities][:current_liabilities]
+              current_liab = data[:sections][:liabilities][:current_liabilities]
+              puts "%-60s %20s" % ["Current Liabilities", format_currency(current_liab, currency)]
+            end
+            if data[:sections][:liabilities][:long_term_liabilities]
+              long_term_liab = data[:sections][:liabilities][:long_term_liabilities]
+              puts "%-60s %20s" % ["Long-term Liabilities", format_currency(long_term_liab, currency)]
+            end
+            total_liab = data[:sections][:liabilities][:total]
+            puts "%-60s %20s" % ["TOTAL LIABILITIES", format_currency(total_liab, currency)]
+          end
+        end
+        
+        # Equity section
+        if data[:sections][:equity]
+          output_section(data[:sections][:equity], currency, "EQUITY")
+        end
+        
+        # Accumulated Net Income section (separate from equity)
+        if data[:sections][:accumulated_net_income]
+          output_section(data[:sections][:accumulated_net_income], currency, "ACCUMULATED NET INCOME")
+        end
+        
+        # Total Liabilities and Equity
+        if data[:sections][:total_liabilities_and_equity]
+          puts "\n"
+          puts "-" * 80
+          total = data[:sections][:total_liabilities_and_equity][:total] || data[:sections][:total_liabilities_and_equity][:value] || 0
+          puts "%-60s %20s" % ["TOTAL LIABILITIES AND EQUITY", format_currency(total, currency)]
+        end
+      end
+
+      def output_cash_flow_statement(data, currency)
+        display_mode = data[:display_mode] || :standard
+
+        if display_mode == :simple
+          output_simple_cash_flow(data, currency)
+        else
+          output_standard_cash_flow(data, currency)
+        end
+      end
+
+      def output_standard_cash_flow(data, currency)
+        sections = data[:sections] || {}
+
+        # Operating Activities
+        if sections[:operating]
+          puts "\nOPERATING ACTIVITIES"
+          puts "-" * 80
+          if sections[:operating][:items]
+            sections[:operating][:items].each do |item|
+              output_cash_flow_item(item, currency)
+            end
+          end
+          puts "-" * 80
+          puts "%-60s %20s" % ["Net Cash from Operating Activities", format_currency(sections[:operating][:total] || 0, currency)]
+        end
+
+        # Investing Activities
+        if sections[:investing]
+          puts "\nINVESTING ACTIVITIES"
+          puts "-" * 80
+          if sections[:investing][:items] && sections[:investing][:items].any?
+            sections[:investing][:items].each do |item|
+              output_cash_flow_item(item, currency)
+            end
+          end
+          puts "-" * 80
+          puts "%-60s %20s" % ["Net Cash from Investing Activities", format_currency(sections[:investing][:total] || 0, currency)]
+        end
+
+        # Financing Activities
+        if sections[:financing]
+          puts "\nFINANCING ACTIVITIES"
+          puts "-" * 80
+          if sections[:financing][:items] && sections[:financing][:items].any?
+            sections[:financing][:items].each do |item|
+              output_cash_flow_item(item, currency)
+            end
+          end
+          puts "-" * 80
+          puts "%-60s %20s" % ["Net Cash from Financing Activities", format_currency(sections[:financing][:total] || 0, currency)]
+        end
+
+        # Summary
+        puts "\n"
+        puts "=" * 80
+
+        if sections[:net_change_in_cash]
+          net_change = sections[:net_change_in_cash][:total] || sections[:net_change_in_cash][:value] || 0
+          puts "%-60s %20s" % ["NET CHANGE IN CASH", format_currency(net_change, currency)]
+        end
+
+        if sections[:beginning_cash]
+          beginning_cash = sections[:beginning_cash][:total] || sections[:beginning_cash][:value] || 0
+          puts "%-60s %20s" % ["Beginning Cash Balance", format_currency(beginning_cash, currency)]
+        end
+
+        if sections[:ending_cash]
+          ending_cash = sections[:ending_cash][:total] || sections[:ending_cash][:value] || 0
+          puts "%-60s %20s" % ["ENDING CASH BALANCE", format_currency(ending_cash, currency)]
+        end
+      end
+
+      def output_simple_cash_flow(data, currency)
+        sections = data[:sections] || {}
+
+        # Cash Inflows
+        if sections[:cash_in]
+          puts "\nCASH INFLOWS"
+          puts "-" * 80
+          if sections[:cash_in][:items]
+            sections[:cash_in][:items].each do |item|
+              output_cash_flow_item(item, currency)
+            end
+          end
+          puts "-" * 80
+          puts "%-60s %20s" % ["Total Cash Inflows", format_currency(sections[:cash_in][:total] || 0, currency)]
+        end
+
+        # Cash Outflows
+        if sections[:cash_out]
+          puts "\nCASH OUTFLOWS"
+          puts "-" * 80
+          if sections[:cash_out][:items]
+            sections[:cash_out][:items].each do |item|
+              output_cash_flow_item(item, currency)
+            end
+          end
+          puts "-" * 80
+          puts "%-60s %20s" % ["Total Cash Outflows", format_currency(sections[:cash_out][:total] || 0, currency)]
+        end
+
+        # Summary
+        puts "\n"
+        puts "=" * 80
+
+        if sections[:net_change_in_cash]
+          net_change = sections[:net_change_in_cash][:total] || sections[:net_change_in_cash][:value] || 0
+          puts "%-60s %20s" % ["NET CHANGE IN CASH", format_currency(net_change, currency)]
+        end
+
+        if sections[:beginning_cash]
+          beginning_cash = sections[:beginning_cash][:total] || sections[:beginning_cash][:value] || 0
+          puts "%-60s %20s" % ["Beginning Cash Balance", format_currency(beginning_cash, currency)]
+        end
+
+        if sections[:ending_cash]
+          ending_cash = sections[:ending_cash][:total] || sections[:ending_cash][:value] || 0
+          puts "%-60s %20s" % ["ENDING CASH BALANCE", format_currency(ending_cash, currency)]
+        end
+      end
+
+      def output_cash_flow_item(item, currency, indent = 0)
+        prefix = "  " * indent
+        display_name = item[:display_name] || item[:name]
+        value = item[:value] || 0
+        puts "%-60s %20s" % ["#{prefix}#{display_name}", format_currency(value, currency)]
+      end
+      
+      def output_balance_sheet_section(section, currency, section_name)
+        puts "\n#{section_name}"
+        puts "-" * 80
+        
+        if section[:items]
+          section[:items].each do |item|
+            output_item_row(item, currency, 0, show_category_total: false)
+          end
+        end
+      end
+      
+      def output_section(section, currency, section_name, show_total: false)
+        puts "\n#{section_name}"
+        puts "-" * 80
+        
+        if section[:items]
+          section[:items].each do |item|
+            output_item_row(item, currency, show_category_total: false)
+          end
+        end
+        
+        # Show section total only if requested (for top-level sections)
+        if show_total && section[:total]
+          puts "-" * 80
+          puts "%-60s %20s" % ["TOTAL #{section_name}", format_currency(section[:total], currency)]
+        end
+      end
+      
+      def output_item_row(item, currency, indent = 0, show_category_total: false)
+        prefix = "  " * indent
+        display_name = item[:display_name] || item[:name]
+        
+        if item[:subcategories] && item[:subcategories].any?
+          # Parent category with children - show header only if no value at parent level
+          if item[:value] && item[:value] != 0
+            # Show parent with value, then children
+            puts "%-60s %20s" % ["#{prefix}#{display_name}", format_currency(item[:value], currency)]
+            item[:subcategories].each do |sub|
+              output_item_row(sub, currency, indent + 1, show_category_total: show_category_total)
+            end
+          else
+            # Show parent as header, then children
+          puts "#{prefix}#{display_name}:"
+            item[:subcategories].each do |sub|
+              output_item_row(sub, currency, indent + 1, show_category_total: show_category_total)
+            end
+            # Show subtotal only if explicitly requested (for nested categories)
+            if show_category_total && item[:value]
+              puts "%-60s %20s" % ["#{prefix}  Subtotal", format_currency(item[:value], currency)]
+            end
+          end
+        else
+          # Leaf item
+          value_str = format_currency(item[:value], currency)
+          puts "%-60s %20s" % ["#{prefix}#{display_name}", value_str]
+        end
+      end
+      
+      def output_item(item, currency, indent = 0)
+        # Legacy method for backward compatibility
+        output_item_row(item, currency, indent)
+      end
+      
+      def format_currency(value, currency = nil)
+        currency ||= @report.output_currency
+        
+        if value.is_a?(Money)
+          "#{currency_symbol(value.currency.iso_code)}#{format_number(value)}"
+        elsif value
+          "#{currency_symbol(currency)}#{format_number(value)}"
+        else
+          "#{currency_symbol(currency)}0"
+        end
+      end
+      
+      def format_display_value(value, format_type, currency = nil)
+        currency ||= @report.output_currency
+        
+        case format_type
+        when :percentage
+          "#{format_number(value)}%"
+        when :currency
+          format_currency(value, currency)
+        when :number
+          format_number(value)
+        else
+          format_number(value)
+        end
+      end
+      
+      def format_number(value)
+        if value.is_a?(Money)
+          formatted = sprintf("%.2f", value.to_f)
+        elsif value.is_a?(Numeric)
+          # Always use 2 decimal places
+          formatted = sprintf("%.2f", value)
+        else
+          formatted = value.to_s
+        end
+        
+        # Add thousands separator (commas)
+        if formatted.is_a?(String) && formatted =~ /^-?\d+\.\d+$/
+          # Split on decimal point
+          parts = formatted.split('.')
+          integer_part = parts[0]
+          decimal_part = parts[1]
+          
+          # Handle negative sign
+          is_negative = integer_part.start_with?('-')
+          integer_part = integer_part.sub(/^-/, '') if is_negative
+          
+          # Add commas to integer part
+          integer_part = integer_part.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+          
+          # Restore negative sign if needed
+          integer_part = "-#{integer_part}" if is_negative
+          
+          formatted = "#{integer_part}.#{decimal_part}"
+        end
+        
+        formatted
+      end
+      
+      def currency_symbol(currency_code)
+        case currency_code.to_s.upcase
+        when 'USD'
+          '$'
+        when 'EUR'
+          '€'
+        when 'GBP'
+          '£'
+        when 'JPY'
+          '¥'
+        else
+          "#{currency_code} "
+        end
+      end
+      
+      def output_statement_comments(comments)
+        puts "\n" + "=" * 80
+        puts "STATEMENT NOTES"
+        puts "=" * 80
+        
+        comments.each do |category_name, comment|
+          puts "• #{humanize_category_name(category_name)}: #{comment}"
+        end
+        
+        puts "=" * 80
+      end
+      
+      def humanize_category_name(name)
+        name.to_s.split('_').map(&:capitalize).join(' ')
+      end
+      
+      def output_monthly_breakdown(data, currency)
+        breakdown_mode = options[:monthly_breakdown] || :detailed
+        
+        puts "=" * 120
+        puts "MONTHLY BREAKDOWN (#{breakdown_mode.to_s.upcase})"
+        puts "=" * 120
+        
+        if breakdown_mode == :average
+          output_average_monthly(data, currency)
+        else
+          output_detailed_monthly(data, currency)
+        end
+      end
+      
+      def output_average_monthly(data, currency)
+        start_date = @report.start_date
+        end_date = @report.end_date
+        
+        # Calculate number of months
+        months_count = ((end_date.year - start_date.year) * 12 + end_date.month - start_date.month + 1)
+        
+        puts "Average Month (calculated over #{months_count} months: #{start_date.strftime('%b %Y')} - #{end_date.strftime('%b %Y')})"
+        puts "=" * 120
+        puts ""
+        
+        # Calculate averages
+        puts "%-40s %20s" % ["Item", "Avg Month (#{currency})"]
+        puts "-" * 120
+        
+        # Income section
+        if data[:sections][:income]
+          output_monthly_section(data[:sections][:income], currency, months_count, "INCOME")
+        end
+        
+        puts ""
+        
+        # Expense section
+        if data[:sections][:expenses]
+          output_monthly_section(data[:sections][:expenses], currency, months_count, "EXPENSES")
+        end
+        
+        puts ""
+        puts "-" * 120
+        
+        # Net Income
+        total_income = data[:sections][:income][:total] || 0
+        total_expenses = data[:sections][:expenses][:total] || 0
+        avg_net_income = (total_income - total_expenses) / months_count.to_f
+        
+        puts "%-40s %20s" % ["NET INCOME", format_currency(avg_net_income, currency)]
+        puts "=" * 120
+      end
+      
+      def output_detailed_monthly(data, currency)
+        start_date = @report.start_date
+        end_date = @report.end_date
+        
+        # Generate list of months
+        months = []
+        current_date = start_date
+        while current_date <= end_date
+          months << current_date.strftime("%b %Y")
+          current_date = current_date >> 1
+        end
+        
+        # Determine column width based on number of months
+        col_width = [15, 120 / (months.length + 1)].max
+        total_width = 40 + (col_width * months.length)
+        
+        # Headers
+        header_format = "%-40s" + (" %#{col_width-1}s" * months.length)
+        puts header_format % (["Item"] + months)
+        puts "-" * total_width
+        
+        # Income section
+        if data[:sections][:income]
+          puts "\n#{data[:sections][:income][:name]}"
+          puts "-" * total_width
+          output_detailed_section_items(data[:sections][:income], months.length, col_width)
+          
+          # Total income
+          income_total = data[:sections][:income][:total] || 0
+          monthly_income = income_total / 12.0
+          values = ["TOTAL INCOME"] + [format_currency(monthly_income, currency)] * months.length
+          puts (header_format % values)
+        end
+        
+        puts ""
+        
+        # Expense section
+        if data[:sections][:expenses]
+          puts "\n#{data[:sections][:expenses][:name]}"
+          puts "-" * total_width
+          output_detailed_section_items(data[:sections][:expenses], months.length, col_width)
+          
+          # Total expenses
+          expense_total = data[:sections][:expenses][:total] || 0
+          monthly_expense = expense_total / 12.0
+          values = ["TOTAL EXPENSES"] + [format_currency(monthly_expense, currency)] * months.length
+          puts (header_format % values)
+        end
+        
+        puts ""
+        puts "-" * total_width
+        
+        # Net Income
+        total_income = data[:sections][:income][:total] || 0
+        total_expenses = data[:sections][:expenses][:total] || 0
+        monthly_net = (total_income - total_expenses) / 12.0
+        values = ["NET INCOME"] + [format_currency(monthly_net, currency)] * months.length
+        puts (header_format % values)
+        puts "=" * 120
+      end
+      
+      def output_monthly_section(section, currency, months_count, label)
+        puts "\n#{label}"
+        puts "-" * 120
+        
+        if section[:items]
+          section[:items].each do |item|
+            output_monthly_item(item, currency, months_count)
+          end
+        end
+        
+        avg_total = section[:total] ? section[:total] / months_count.to_f : 0
+        puts "%-40s %20s" % ["Total #{section[:name]}", format_currency(avg_total, currency)]
+      end
+      
+      def output_monthly_item(item, currency, months_count, indent = 0)
+        prefix = "  " * indent
+        display_name = item[:display_name] || item[:name]
+        
+        if item[:subcategories]
+          puts "%-40s" % ["#{prefix}#{display_name}:"]
+          item[:subcategories].each { |sub| output_monthly_item(sub, currency, months_count, indent + 1) }
+        else
+          avg_value = item[:value] ? item[:value] / months_count.to_f : 0
+          puts "%-40s %20s" % ["#{prefix}#{display_name}", format_currency(avg_value, currency)]
+        end
+      end
+      
+      def output_detailed_section_items(section, months_count, col_width, start_date = nil)
+        currency = @report.output_currency
+        header_format = "%-40s" + (" %#{col_width-1}s" * months_count)
+        start_date ||= @report.start_date
+        
+        if section[:items]
+          section[:items].each do |item|
+            output_detailed_item_row(item, months_count, col_width, header_format, currency, start_date)
+          end
+        end
+      end
+      
+      def output_detailed_item_row(item, months_count, col_width, format_str, currency, start_date = nil, indent = 0)
+        prefix = "  " * indent
+        display_name = item[:display_name] || item[:name]
+        start_date ||= @report.start_date
+        
+        if item[:subcategories]
+          # Parent category
+          puts "#{prefix}#{display_name}:"
+          item[:subcategories].each do |sub|
+            output_detailed_item_row(sub, months_count, col_width, format_str, currency, start_date, indent + 1)
+          end
+        else
+          # Leaf item - use report data or model methods
+          # For monthly breakdown, we should use the report's monthly data if available
+          # Otherwise, fall back to dividing annual value by 12
+          monthly_values = []
+          current_date = start_date
+          
+          months_count.times do
+            # Try to get monthly value from report data structure
+            # If not available, divide annual value by 12
+            month_value = if item[:value]
+              item[:value] / 12.0
+            else
+              0
+            end
+            
+            monthly_values << format_currency(month_value, currency)
+            current_date = current_date >> 1  # Next month
+          end
+          
+          values = ["#{prefix}#{display_name}"] + monthly_values
+          puts (format_str % values)
+        end
+      end
+      
+      def output_income_statement_periods_columns(periods, header_format, currency, col_width)
+        # Check if we're in separate_cogs mode by looking at first period
+        first_period_data = periods.first
+        first_report_data = first_period_data[:report] || first_period_data
+        separate_cogs_mode = first_report_data[:expense_display_mode] == :separate_cogs
+        
+        # Collect display items from first period
+        display_items = first_report_data[:display_items] || []
+        
+        # Collect all unique items across periods
+        income_items = {}
+        cogs_items = {}
+        expense_items = {}
+        
+        periods.each_with_index do |period_data, idx|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          
+          # Income items
+          if sections[:income] && sections[:income][:items]
+            sections[:income][:items].each do |item|
+              collect_items_for_periods(item, income_items, idx, currency, :income, nil)
+            end
+          end
+          
+          # COGS items (if separate_cogs mode)
+          if separate_cogs_mode && sections[:cogs] && sections[:cogs][:items]
+            sections[:cogs][:items].each do |item|
+              collect_items_for_periods(item, cogs_items, idx, currency, :cogs, nil)
+            end
+          end
+          
+          # Expense items (operating expenses in separate_cogs mode, all expenses otherwise)
+          if sections[:expenses] && sections[:expenses][:items]
+            sections[:expenses][:items].each do |item|
+              collect_items_for_periods(item, expense_items, idx, currency, :expense, nil)
+            end
+          end
+        end
+        
+        # Output display items before income section
+        output_display_items_periods(display_items, :before, :income, periods, header_format, currency)
+        
+        # Output income section
+        puts "\nINCOME"
+        puts "-" * (40 + col_width * periods.length)
+        output_items_periods_columns(income_items, periods, header_format, currency, col_width)
+        
+        # Output income total
+        puts "-" * (40 + col_width * periods.length)
+        income_total_row = ["TOTAL INCOME"]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          income_total = sections[:income] ? (sections[:income][:total] || 0) : 0
+          income_total_row << format_currency(income_total, currency)
+        end
+        puts header_format % income_total_row
+        
+        # Output display items after income section
+        output_display_items_periods(display_items, :after, :income, periods, header_format, currency)
+        
+        # Output COGS section (if separate_cogs mode)
+        if separate_cogs_mode && cogs_items.any?
+          output_display_items_periods(display_items, :before, :cogs, periods, header_format, currency)
+          puts "\nCOST OF GOODS SOLD"
+          puts "-" * (40 + col_width * periods.length)
+          output_items_periods_columns(cogs_items, periods, header_format, currency, col_width)
+          
+          # Output COGS total
+          puts "-" * (40 + col_width * periods.length)
+          cogs_total_row = ["TOTAL COST OF GOODS SOLD"]
+          periods.each do |period_data|
+            report_data = period_data[:report] || period_data
+            sections = report_data[:sections] || {}
+            cogs_total = sections[:cogs] ? (sections[:cogs][:total] || 0) : 0
+            cogs_total_row << format_currency(cogs_total, currency)
+          end
+          puts header_format % cogs_total_row
+          
+          # Output Gross Margin
+          puts "-" * (40 + col_width * periods.length)
+          gross_margin_row = ["GROSS MARGIN"]
+          periods.each do |period_data|
+            report_data = period_data[:report] || period_data
+            sections = report_data[:sections] || {}
+            if sections[:gross_margin]
+              gross_margin = sections[:gross_margin][:total] || sections[:gross_margin][:value] || 0
+              gross_margin_row << format_currency(gross_margin, currency)
+            else
+              gross_margin_row << format_currency(0, currency)
+            end
+          end
+          puts header_format % gross_margin_row
+          
+          # Output display items after gross margin
+          output_display_items_periods(display_items, :after, :gross_margin, periods, header_format, currency)
+          # Output display items in column next to gross margin
+          output_display_items_periods_column(display_items, :gross_margin, periods, header_format, currency)
+        end
+        
+        # Output expense section
+        output_display_items_periods(display_items, :before, :expenses, periods, header_format, currency)
+        section_label = separate_cogs_mode ? "OPERATING EXPENSES" : "EXPENSES"
+        puts "\n#{section_label}"
+        puts "-" * (40 + col_width * periods.length)
+        output_items_periods_columns(expense_items, periods, header_format, currency, col_width)
+        
+        # Output expense total
+        puts "-" * (40 + col_width * periods.length)
+        expense_total_label = separate_cogs_mode ? "TOTAL OPERATING EXPENSES" : "TOTAL EXPENSES"
+        expense_total_row = [expense_total_label]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          expense_total = sections[:expenses] ? (sections[:expenses][:total] || 0) : 0
+          expense_total_row << format_currency(expense_total, currency)
+        end
+        puts header_format % expense_total_row
+        output_display_items_periods(display_items, :after, :expenses, periods, header_format, currency)
+        
+        # Output totals row
+        output_display_items_periods(display_items, :before, :net_income, periods, header_format, currency)
+        puts "-" * (40 + col_width * periods.length)
+        totals_row = ["NET INCOME"]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          totals = report_data[:totals] || {}
+          income = totals[:income] || 0
+          expenses = totals[:expenses] || 0
+          net_income = income - expenses
+          totals_row << format_currency(net_income, currency)
+        end
+        puts header_format % totals_row
+        output_display_items_periods(display_items, :after, :net_income, periods, header_format, currency)
+      end
+      
+      def output_display_items_periods(display_items, position_type, section_key, periods, header_format, currency)
+        items = display_items.select { |item| item[position_type] == section_key }
+        return if items.empty?
+        
+        # Sort by order
+        items = items.sort_by { |item| item[:order] || 0 }
+        
+        items.each do |item|
+          row = [item[:label]]
+          
+          periods.each_with_index do |period_data, idx|
+            report_data = period_data[:report] || period_data
+            period_display_items = report_data[:display_items] || []
+            
+            # Find this item in the period's display items
+            period_item = period_display_items.find { |di| di[:name] == item[:name] }
+            
+            if period_item
+              value_str = format_display_value(period_item[:value], period_item[:format], currency)
+              row << value_str
+            else
+              row << format_display_value(0, item[:format], currency)
+            end
+          end
+          
+          puts header_format % row
+        end
+      end
+      
+      def output_display_items_periods_column(display_items, section_key, periods, header_format, currency)
+        items = display_items.select { |item| item[:column] == section_key }
+        return if items.empty?
+        
+        # Sort by order
+        items = items.sort_by { |item| item[:order] || 0 }
+        
+        items.each do |item|
+          row = ["  #{item[:label]}"]
+          
+          periods.each_with_index do |period_data, idx|
+            report_data = period_data[:report] || period_data
+            period_display_items = report_data[:display_items] || []
+            
+            # Find this item in the period's display items
+            period_item = period_display_items.find { |di| di[:name] == item[:name] }
+            
+            if item[:last_column_only]
+              # Only show in last column
+              if idx == periods.length - 1 && period_item
+                value_str = format_display_value(period_item[:value], period_item[:format], currency)
+                row << value_str
+              else
+                row << ""
+              end
+            else
+              # Show in all columns
+              if period_item
+                value_str = format_display_value(period_item[:value], period_item[:format], currency)
+                row << value_str
+              else
+                row << format_display_value(0, item[:format], currency)
+              end
+            end
+          end
+          
+          puts header_format % row
+        end
+      end
+      
+      def output_balance_sheet_periods_columns(periods, header_format, currency, col_width)
+        # Collect all unique items across periods
+        all_items = {}
+        
+        periods.each_with_index do |period_data, idx|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          
+          # Asset items
+          if sections[:assets] && sections[:assets][:items]
+            sections[:assets][:items].each do |item|
+              collect_items_for_periods(item, all_items, idx, currency, :asset, nil)
+            end
+          end
+          
+          # Liability items
+          if sections[:liabilities] && sections[:liabilities][:items]
+            sections[:liabilities][:items].each do |item|
+              collect_items_for_periods(item, all_items, idx, currency, :liability, nil)
+            end
+          end
+          
+          # Equity items
+          if sections[:equity] && sections[:equity][:items]
+            sections[:equity][:items].each do |item|
+              collect_items_for_periods(item, all_items, idx, currency, :equity, nil)
+            end
+          end
+          
+          # Accumulated Net Income items
+          if sections[:accumulated_net_income] && sections[:accumulated_net_income][:items]
+            sections[:accumulated_net_income][:items].each do |item|
+              collect_items_for_periods(item, all_items, idx, currency, :accumulated_net_income, nil)
+            end
+          end
+        end
+        
+        # Output assets section
+        puts "\nASSETS"
+        puts "-" * (40 + col_width * periods.length)
+        output_items_periods_columns(all_items.select { |k, v| v[:type] == :asset }, periods, header_format, currency, col_width)
+        
+        # Output liabilities section
+        puts "\nLIABILITIES"
+        puts "-" * (40 + col_width * periods.length)
+        output_items_periods_columns(all_items.select { |k, v| v[:type] == :liability }, periods, header_format, currency, col_width)
+        
+        # Output equity section
+        puts "\nEQUITY"
+        puts "-" * (40 + col_width * periods.length)
+        output_items_periods_columns(all_items.select { |k, v| v[:type] == :equity }, periods, header_format, currency, col_width)
+        
+        # Output accumulated net income section
+        accumulated_net_income_items = all_items.select { |k, v| v[:type] == :accumulated_net_income }
+        if accumulated_net_income_items.any?
+          puts "\nACCUMULATED NET INCOME"
+          puts "-" * (40 + col_width * periods.length)
+          output_items_periods_columns(accumulated_net_income_items, periods, header_format, currency, col_width)
+        end
+      end
+
+      def output_cash_flow_statement_periods_columns(periods, header_format, currency, col_width)
+        # Check display mode from first period
+        first_period_data = periods.first
+        first_report_data = first_period_data[:report] || first_period_data
+        display_mode = first_report_data[:display_mode] || :standard
+
+        if display_mode == :simple
+          output_simple_cash_flow_periods_columns(periods, header_format, currency, col_width)
+        else
+          output_standard_cash_flow_periods_columns(periods, header_format, currency, col_width)
+        end
+      end
+
+      def output_standard_cash_flow_periods_columns(periods, header_format, currency, col_width)
+        line_width = 40 + col_width * periods.length
+
+        # Operating Activities
+        puts "\nOPERATING ACTIVITIES"
+        puts "-" * line_width
+        output_cash_flow_section_items_periods(:operating, periods, header_format, currency)
+        puts "-" * line_width
+        operating_row = ["Net Cash from Operating Activities"]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          operating_total = sections[:operating] ? (sections[:operating][:total] || 0) : 0
+          operating_row << format_currency(operating_total, currency)
+        end
+        puts header_format % operating_row
+
+        # Investing Activities
+        puts "\nINVESTING ACTIVITIES"
+        puts "-" * line_width
+        output_cash_flow_section_items_periods(:investing, periods, header_format, currency)
+        puts "-" * line_width
+        investing_row = ["Net Cash from Investing Activities"]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          investing_total = sections[:investing] ? (sections[:investing][:total] || 0) : 0
+          investing_row << format_currency(investing_total, currency)
+        end
+        puts header_format % investing_row
+
+        # Financing Activities
+        puts "\nFINANCING ACTIVITIES"
+        puts "-" * line_width
+        output_cash_flow_section_items_periods(:financing, periods, header_format, currency)
+        puts "-" * line_width
+        financing_row = ["Net Cash from Financing Activities"]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          financing_total = sections[:financing] ? (sections[:financing][:total] || 0) : 0
+          financing_row << format_currency(financing_total, currency)
+        end
+        puts header_format % financing_row
+
+        # Summary section
+        puts "\n"
+        puts "-" * line_width
+
+        # Net Change in Cash
+        net_change_row = ["NET CHANGE IN CASH"]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          net_change = sections[:net_change_in_cash] ? (sections[:net_change_in_cash][:total] || sections[:net_change_in_cash][:value] || 0) : 0
+          net_change_row << format_currency(net_change, currency)
+        end
+        puts header_format % net_change_row
+
+        # Beginning Cash Balance
+        beginning_row = ["Beginning Cash Balance"]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          beginning_cash = sections[:beginning_cash] ? (sections[:beginning_cash][:total] || sections[:beginning_cash][:value] || 0) : 0
+          beginning_row << format_currency(beginning_cash, currency)
+        end
+        puts header_format % beginning_row
+
+        # Ending Cash Balance
+        ending_row = ["ENDING CASH BALANCE"]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          ending_cash = sections[:ending_cash] ? (sections[:ending_cash][:total] || sections[:ending_cash][:value] || 0) : 0
+          ending_row << format_currency(ending_cash, currency)
+        end
+        puts header_format % ending_row
+      end
+
+      def output_simple_cash_flow_periods_columns(periods, header_format, currency, col_width)
+        line_width = 40 + col_width * periods.length
+
+        # Cash Inflows
+        puts "\nCASH INFLOWS"
+        puts "-" * line_width
+        output_cash_flow_section_items_periods(:cash_in, periods, header_format, currency)
+        puts "-" * line_width
+        cash_in_row = ["Total Cash Inflows"]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          cash_in_total = sections[:cash_in] ? (sections[:cash_in][:total] || 0) : 0
+          cash_in_row << format_currency(cash_in_total, currency)
+        end
+        puts header_format % cash_in_row
+
+        # Cash Outflows
+        puts "\nCASH OUTFLOWS"
+        puts "-" * line_width
+        output_cash_flow_section_items_periods(:cash_out, periods, header_format, currency)
+        puts "-" * line_width
+        cash_out_row = ["Total Cash Outflows"]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          cash_out_total = sections[:cash_out] ? (sections[:cash_out][:total] || 0) : 0
+          cash_out_row << format_currency(cash_out_total, currency)
+        end
+        puts header_format % cash_out_row
+
+        # Summary section
+        puts "\n"
+        puts "-" * line_width
+
+        # Net Change in Cash
+        net_change_row = ["NET CHANGE IN CASH"]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          net_change = sections[:net_change_in_cash] ? (sections[:net_change_in_cash][:total] || sections[:net_change_in_cash][:value] || 0) : 0
+          net_change_row << format_currency(net_change, currency)
+        end
+        puts header_format % net_change_row
+
+        # Beginning Cash Balance
+        beginning_row = ["Beginning Cash Balance"]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          beginning_cash = sections[:beginning_cash] ? (sections[:beginning_cash][:total] || sections[:beginning_cash][:value] || 0) : 0
+          beginning_row << format_currency(beginning_cash, currency)
+        end
+        puts header_format % beginning_row
+
+        # Ending Cash Balance
+        ending_row = ["ENDING CASH BALANCE"]
+        periods.each do |period_data|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+          ending_cash = sections[:ending_cash] ? (sections[:ending_cash][:total] || sections[:ending_cash][:value] || 0) : 0
+          ending_row << format_currency(ending_cash, currency)
+        end
+        puts header_format % ending_row
+      end
+
+      def output_cash_flow_section_items_periods(section_key, periods, header_format, currency)
+        # Collect all unique items across periods for this section
+        all_items = {}
+
+        periods.each_with_index do |period_data, idx|
+          report_data = period_data[:report] || period_data
+          sections = report_data[:sections] || {}
+
+          if sections[section_key] && sections[section_key][:items]
+            sections[section_key][:items].each do |item|
+              item_name = item[:name] || item[:display_name]
+              unless all_items[item_name]
+                all_items[item_name] = {
+                  name: item[:display_name] || item[:name],
+                  values: []
+                }
+              end
+
+              # Ensure values array is long enough
+              while all_items[item_name][:values].length < idx
+                all_items[item_name][:values] << 0
+              end
+
+              all_items[item_name][:values][idx] = item[:value] || 0
+            end
+          end
+        end
+
+        # Output each item
+        all_items.each do |_key, item_data|
+          row = ["  #{item_data[:name]}"]
+
+          # Ensure we have values for all periods
+          while item_data[:values].length < periods.length
+            item_data[:values] << 0
+          end
+
+          item_data[:values].each do |val|
+            row << format_currency(val || 0, currency)
+          end
+
+          puts header_format % row
+        end
+      end
+
+      def collect_items_for_periods(item, all_items, period_idx, currency, type = nil, parent_key = nil)
+        key = item[:name] || item[:display_name]
+        type ||= :income # default for income statements
+        
+        # Initialize if first time seeing this item
+        unless all_items[key]
+          all_items[key] = {
+            name: item[:display_name] || item[:name],
+            indent: item[:indent] || 0,
+            type: type,
+            values: [],
+            parent: parent_key,
+            children: []
+          }
+        end
+        
+        # Track parent-child relationship
+        if parent_key && !all_items[parent_key][:children].include?(key)
+          all_items[parent_key][:children] << key
+        end
+        
+        # Ensure values array is long enough
+        while all_items[key][:values].length < period_idx
+          all_items[key][:values] << nil
+        end
+        
+        # Set value for this period
+        value = item[:value] || 0
+        all_items[key][:values][period_idx] = value
+        
+        # Handle subcategories recursively
+        if item[:subcategories] && item[:subcategories].any?
+          item[:subcategories].each do |sub|
+            collect_items_for_periods(sub, all_items, period_idx, currency, type, key)
+          end
+        end
+      end
+      
+      def output_items_periods_columns(items_hash, periods, header_format, currency, col_width)
+        # Find root items (items without parents)
+        root_items = items_hash.select { |k, v| v[:parent].nil? }.keys
+        
+        # Output items in hierarchical order with recursion protection
+        visited = Set.new
+        root_items.each do |root_key|
+          output_item_hierarchical(root_key, items_hash, periods, header_format, currency, col_width, visited, 0)
+        end
+      end
+      
+      def output_item_hierarchical(item_key, items_hash, periods, header_format, currency, col_width, visited = Set.new, depth = 0)
+        # Protect against infinite recursion
+        return if visited.include?(item_key)
+        return if depth > 50  # Maximum depth limit
+
+        item_data = items_hash[item_key]
+        return unless item_data
+
+        # Mark as visited
+        visited.add(item_key)
+
+        # Output this item
+        prefix = "  " * (item_data[:indent] || 0)
+        values = ["#{prefix}#{item_data[:name]}"]
+
+        # Ensure we have values for all periods
+        while item_data[:values].length < periods.length
+          item_data[:values] << nil
+        end
+
+        # All values are stored as positive
+        item_data[:values].each do |val|
+          display_val = val || 0
+          values << format_currency(display_val, currency)
+        end
+
+        puts header_format % values
+
+        # Output children items recursively
+        if item_data[:children] && item_data[:children].any?
+          item_data[:children].each do |child_key|
+            output_item_hierarchical(child_key, items_hash, periods, header_format, currency, col_width, visited, depth + 1)
+          end
+        end
+
+        # Remove from visited set after processing children (allows re-visiting in different branches)
+        visited.delete(item_key)
+      end
+
+      def output_scenario_comparison(data, currency)
+        metadata = data[:metadata]
+        base_metrics = data[:base]
+        scenarios = data[:scenarios]
+        variances = data[:variances]
+        scenario_names = metadata[:scenario_names]
+
+        # Use normalized_metrics if available (has labels)
+        normalized_metrics = metadata[:normalized_metrics] || []
+
+        # Calculate column widths
+        label_width = 30
+        value_width = 18
+        num_scenarios = scenario_names.length
+        total_width = label_width + value_width + (value_width * num_scenarios)
+
+        # Header
+        puts "=" * total_width
+        puts "SCENARIO COMPARISON (#{currency})"
+        puts "Period: #{metadata[:start_date]} to #{metadata[:end_date]}"
+        puts "=" * total_width
+        puts ""
+
+        # Column headers
+        header_format = "%-#{label_width}s %#{value_width}s" + (" %#{value_width}s" * num_scenarios)
+        headers = ["Metric", "Base"] + scenario_names.map { |n| humanize_category_name(n) }
+        puts header_format % headers
+        puts "-" * total_width
+
+        # Output each metric using normalized metrics for labels
+        normalized_metrics.each do |metric_config|
+          metric_key = metric_config[:key]
+          metric_label = metric_config[:label]
+          base_value = base_metrics[metric_key] || 0
+
+          # First row: values
+          values_row = [metric_label, format_currency(base_value, currency)]
+          scenario_names.each do |scenario_name|
+            scenario_metrics = scenarios[scenario_name]
+            scenario_value = scenario_metrics ? (scenario_metrics[metric_key] || 0) : 0
+            values_row << format_currency(scenario_value, currency)
+          end
+          puts header_format % values_row
+
+          # Second row: variance percentages (indented, under scenario columns)
+          variance_row = ["", ""]  # Empty for label and base columns
+          scenario_names.each do |scenario_name|
+            if variances[scenario_name]
+              metric_variance = variances[scenario_name][metric_key]
+              if metric_variance
+                pct = metric_variance[:percentage]
+                variance_str = pct >= 0 ? "+#{pct}%" : "#{pct}%"
+                variance_row << variance_str
+              else
+                variance_row << ""
+              end
+            else
+              variance_row << ""
+            end
+          end
+          puts header_format % variance_row
+
+          puts "-" * total_width
+        end
+
+        puts "=" * total_width
+        puts ""
+        puts "Generated at: #{metadata[:generated_at]}"
+      end
+
+      def output_period_comparison(data, currency)
+        metadata = data[:metadata]
+        periods = data[:periods]
+        variances = data[:variances]
+        normalized_metrics = metadata[:normalized_metrics] || []
+
+        # Calculate column widths
+        label_width = 30
+        value_width = 18
+        num_periods = periods.length
+        total_width = label_width + (value_width * num_periods)
+
+        # Header
+        puts "=" * total_width
+        puts "PERIOD COMPARISON (#{currency})"
+        puts "=" * total_width
+        puts ""
+
+        # Column headers
+        header_format = "%-#{label_width}s" + (" %#{value_width}s" * num_periods)
+        headers = ["Metric"] + periods.map { |p| p[:name] }
+        puts header_format % headers
+        puts "-" * total_width
+
+        # Output each metric
+        normalized_metrics.each do |metric_config|
+          metric_key = metric_config[:variable]
+          metric_label = metric_config[:label]
+
+          # First row: values
+          values_row = [metric_label]
+          periods.each do |period|
+            period_value = period[:metrics][metric_key] || 0
+            values_row << format_currency(period_value, currency)
+          end
+          puts header_format % values_row
+
+          # Second row: variance percentages (first period is blank)
+          variance_row = [""]
+          variances.each_with_index do |var_data, idx|
+            if var_data[:variances]
+              metric_variance = var_data[:variances][metric_key]
+              if metric_variance
+                pct = metric_variance[:percentage]
+                variance_str = pct >= 0 ? "+#{pct}%" : "#{pct}%"
+                variance_row << variance_str
+              else
+                variance_row << ""
+              end
+            else
+              variance_row << ""  # First period has no variance
+            end
+          end
+          puts header_format % variance_row
+
+          puts "-" * total_width
+        end
+
+        puts "=" * total_width
+        puts ""
+        puts "Generated at: #{metadata[:generated_at]}"
+      end
+
+      def output_custom_sheet(data)
+        title = data[:title]
+        sections = data[:sections]
+
+        puts "=" * 80
+        puts title.upcase.center(80)
+        puts "=" * 80
+        puts ""
+
+        sections.each do |section|
+          case section[:type]
+          when :header
+            level = section[:level] || 1
+            text = section[:text]
+            if level == 1
+              puts text.upcase
+              puts "=" * text.length
+            else
+              puts text
+              puts "-" * text.length
+            end
+          when :paragraph
+            puts section[:text]
+          when :spacer
+            (section[:rows] || 1).times { puts "" }
+          when :key_value
+            puts "#{section[:label]}: #{section[:value]}"
+          when :bullet_list
+            section[:items].each { |item| puts "  * #{item}" }
+          when :numbered_list
+            section[:items].each_with_index { |item, idx| puts "  #{idx + 1}. #{item}" }
+          when :table
+            output_custom_sheet_table(section)
+          when :hr
+            puts "-" * 80
+          when :note
+            style_prefix = case section[:style]
+                           when :warning then "[!] "
+                           when :error then "[X] "
+                           when :success then "[+] "
+                           else "[i] "
+                           end
+            puts "#{style_prefix}#{section[:text]}"
+          end
+          puts ""
+        end
+
+        if data[:generated_at]
+          puts "-" * 80
+          puts "Generated at: #{data[:generated_at]}"
+        end
+      end
+
+      def output_custom_sheet_table(section)
+        headers = section[:headers]
+        rows = section[:rows]
+
+        if section[:title]
+          puts section[:title]
+          puts "-" * 60
+        end
+
+        # Calculate column widths
+        all_rows = [headers] + rows
+        col_widths = headers.map.with_index do |_, idx|
+          all_rows.map { |row| row[idx].to_s.length }.max
+        end
+
+        # Format string
+        format_str = col_widths.map { |w| "%-#{w + 2}s" }.join(" | ")
+
+        # Output header
+        puts format_str % headers
+        puts "-" * (col_widths.sum + (col_widths.length - 1) * 3 + col_widths.length * 2)
+
+        # Output rows
+        rows.each do |row|
+          puts format_str % row
+        end
+      end
+    end
+  end
+end