class CreateInvoicesAndLineItems < ActiveRecord::Migration[8.1]
  def change
    create_table :invoices do |t|
      t.references :contact,         null: false, foreign_key: true
      t.references :created_by_user, null: false, foreign_key: { to_table: :users }

      t.string  :invoice_number,   null: false
      t.string  :status,           null: false, default: "draft"
      t.string  :currency,         null: false, default: "USD"

      t.date    :issue_date
      t.date    :due_date
      t.text    :notes
      t.text    :payment_terms,    default: "Net 30"

      t.integer :subtotal_cents,   null: false, default: 0
      t.integer :tax_cents,        null: false, default: 0
      t.integer :total_cents,      null: false, default: 0

      t.datetime :sent_at
      t.datetime :paid_at
      t.string   :payment_method
      t.string   :payment_reference

      t.timestamps
    end

    create_table :invoice_line_items do |t|
      t.references :invoice, null: false, foreign_key: true

      t.string  :description,   null: false
      t.integer :quantity,      null: false, default: 1
      t.integer :unit_price_cents, null: false
      t.integer :total_cents,   null: false

      t.timestamps
    end

    add_index :invoices, :status
    add_index :invoices, :invoice_number, unique: true
    add_index :invoices, [:contact_id, :status]
    add_index :invoices, :due_date
  end
end

class CreateExpensesAndReports < ActiveRecord::Migration[8.1]
  def change
    create_table :expense_reports do |t|
      t.references :submitted_by_user, null: false, foreign_key: { to_table: :users }
      t.references :approved_by_user,  foreign_key: { to_table: :users }

      t.string  :title,          null: false
      t.string  :status,         null: false, default: "draft"
      t.string  :currency,       null: false, default: "USD"

      t.integer :total_cents,    null: false, default: 0

      t.datetime :submitted_at
      t.datetime :approved_at
      t.datetime :rejected_at
      t.datetime :paid_at

      t.text    :rejection_notes
      t.text    :notes

      t.timestamps
    end

    create_table :expenses do |t|
      t.references :expense_report, foreign_key: true
      t.references :submitted_by_user, null: false, foreign_key: { to_table: :users }

      t.string  :description,       null: false
      t.string  :category,          null: false
      t.integer :amount_cents,      null: false
      t.string  :currency,          null: false, default: "USD"
      t.date    :expense_date,      null: false
      t.string  :status,            null: false, default: "draft"
      t.string  :merchant_name
      t.text    :notes

      t.datetime :reported_at
      t.datetime :approved_at
      t.datetime :rejected_at

      t.timestamps
    end

    add_index :expense_reports, :status
    add_index :expenses, :status
    add_index :expenses, [:expense_report_id, :status]
    add_index :expenses, :expense_date
  end
end

# frozen_string_literal: true

class Invoice < ApplicationRecord
  include Fosm::Lifecycle

  belongs_to :contact
  belongs_to :created_by_user, class_name: "User"

  has_many :line_items, class_name: "InvoiceLineItem", dependent: :destroy
  accepts_nested_attributes_for :line_items, allow_destroy: true,
                                              reject_if: :all_blank

  validates :invoice_number, presence: true, uniqueness: true
  validates :currency,       presence: true
  validates :due_date,       presence: true, if: -> { sent? || paid? }

  enum :status, {
    draft:     "draft",
    sent:      "sent",
    paid:      "paid",
    overdue:   "overdue",
    cancelled: "cancelled"
  }, default: :draft

  before_validation :calculate_totals
  before_create     :assign_invoice_number

  # ── FOSM Lifecycle ────────────────────────────────────────────────────────
  # Based on Parolkar's FOSM paper: https://www.parolkar.com/fosm
  lifecycle do
    state :draft,     label: "Draft",     color: "slate",  initial: true
    state :sent,      label: "Sent",      color: "blue"
    state :paid,      label: "Paid",      color: "green",  terminal: true
    state :overdue,   label: "Overdue",   color: "orange"
    state :cancelled, label: "Cancelled", color: "red",    terminal: true

    event :send_invoice,  from: :draft,          to: :sent,      label: "Send Invoice"
    event :pay,           from: [:sent, :overdue], to: :paid,     label: "Mark as Paid"
    event :mark_overdue,  from: :sent,            to: :overdue,   label: "Mark Overdue"
    event :cancel,        from: [:draft, :sent, :overdue], to: :cancelled, label: "Cancel"

    actors :human, :system

    # Guards
    guard :has_line_items, on: :send_invoice,
          description: "Invoice must have at least one line item before sending" do |invoice|
      invoice.line_items.any?
    end

    guard :has_due_date, on: :send_invoice,
          description: "Invoice must have a due date" do |invoice|
      invoice.due_date.present?
    end

    guard :has_positive_total, on: :send_invoice,
          description: "Invoice total must be greater than zero" do |invoice|
      invoice.total_cents > 0
    end

    # Side effects
    side_effect :set_sent_metadata, on: :send_invoice,
                description: "Record sent timestamp and set issue date" do |invoice, _t|
      invoice.update!(sent_at: Time.current, issue_date: invoice.issue_date || Date.current)
    end

    side_effect :email_invoice, on: :send_invoice,
                description: "Email invoice to contact" do |invoice, _t|
      InvoiceMailer.send_invoice(invoice).deliver_later
    end

    side_effect :record_payment, on: :pay,
                description: "Record payment timestamp" do |invoice, transition|
      invoice.update!(paid_at: Time.current)
      Fosm::EventBus.publish("invoice.paid", {
        invoice_id:   invoice.id,
        contact_id:   invoice.contact_id,
        amount_cents: invoice.total_cents,
        actor_id:     transition.actor_id
      })
    end
  end
  # ── End Lifecycle ─────────────────────────────────────────────────────────

  scope :outstanding, -> { where(status: %w[sent overdue]) }
  scope :overdue_today, -> { sent.where("due_date < ?", Date.current) }

  def send!(actor:)
    transition!(:send_invoice, actor: actor)
  end

  def pay!(actor:, method: nil, reference: nil)
    update!(payment_method: method, payment_reference: reference) if method.present?
    transition!(:pay, actor: actor)
  end

  def mark_overdue!(actor: nil)
    transition!(:mark_overdue, actor: actor)
  end

  def cancel!(actor:)
    transition!(:cancel, actor: actor)
  end

  def overdue?
    status == "overdue" || (sent? && due_date.present? && due_date < Date.current)
  end

  def days_overdue
    return 0 unless overdue? && due_date.present?
    (Date.current - due_date).to_i
  end

  def total_formatted
    "$#{(total_cents / 100.0).round(2)}"
  end

  private

  def calculate_totals
    return unless line_items.loaded? || line_items.any?
    self.subtotal_cents = line_items.reject(&:marked_for_destruction?).sum(&:total_cents)
    self.tax_cents      = (subtotal_cents * 0.0).to_i   # Extend for tax logic as needed
    self.total_cents    = subtotal_cents + tax_cents
  end

  def assign_invoice_number
    self.invoice_number ||= "INV-#{Time.current.year}-#{Invoice.count + 1001}"
  end
end

# frozen_string_literal: true

class InvoiceLineItem < ApplicationRecord
  belongs_to :invoice

  validates :description,     presence: true
  validates :quantity,        numericality: { greater_than: 0 }
  validates :unit_price_cents, numericality: { greater_than_or_equal_to: 0 }

  before_save :calculate_total

  def unit_price_formatted
    "$#{(unit_price_cents / 100.0).round(2)}"
  end

  def total_formatted
    "$#{(total_cents / 100.0).round(2)}"
  end

  private

  def calculate_total
    self.total_cents = quantity * unit_price_cents
  end
end

# frozen_string_literal: true

class Expense < ApplicationRecord
  include Fosm::Lifecycle

  belongs_to :expense_report, optional: true
  belongs_to :submitted_by_user, class_name: "User"

  has_one_attached :receipt

  CATEGORIES = %w[
    travel accommodation meals_entertainment software_tools
    equipment marketing_advertising office_supplies other
  ].freeze

  validates :description,   presence: true
  validates :category,      presence: true, inclusion: { in: CATEGORIES }
  validates :amount_cents,  numericality: { greater_than: 0 }
  validates :expense_date,  presence: true

  enum :status, {
    draft:    "draft",
    reported: "reported",
    approved: "approved",
    rejected: "rejected"
  }, default: :draft

  # ── FOSM Lifecycle ────────────────────────────────────────────────────────
  # Based on Parolkar's FOSM paper: https://www.parolkar.com/fosm
  lifecycle do
    state :draft,    label: "Draft",    color: "slate",  initial: true
    state :reported, label: "Reported", color: "blue"
    state :approved, label: "Approved", color: "green",  terminal: true
    state :rejected, label: "Rejected", color: "red",    terminal: true

    event :report,  from: :draft,     to: :reported, label: "Report Expense"
    event :approve, from: :reported,  to: :approved, label: "Approve"
    event :reject,  from: :reported,  to: :rejected, label: "Reject"

    actors :human, :system

    # Guard: receipt must be attached before reporting
    guard :has_receipt, on: :report,
          description: "A receipt must be attached before reporting an expense" do |expense|
      expense.receipt.attached?
    end

    # Guard: expense must have a parent report
    guard :has_expense_report, on: :report,
          description: "Expense must be added to a report before reporting" do |expense|
      expense.expense_report_id.present?
    end

    # Side effects
    side_effect :record_reported_at, on: :report,
                description: "Record reported timestamp" do |expense, _t|
      expense.update!(reported_at: Time.current)
    end

    side_effect :record_approved_at, on: :approve,
                description: "Record approved timestamp" do |expense, _t|
      expense.update!(approved_at: Time.current)
    end

    side_effect :record_rejected_at, on: :reject,
                description: "Record rejected timestamp" do |expense, _t|
      expense.update!(rejected_at: Time.current)
    end
  end
  # ── End Lifecycle ─────────────────────────────────────────────────────────

  def amount_formatted
    "$#{(amount_cents / 100.0).round(2)}"
  end

  def approve_from_report!(actor: nil)
    transition!(:approve, actor: actor)
  end

  def reject_from_report!(actor: nil)
    transition!(:reject, actor: actor)
  end
end

# frozen_string_literal: true

class ExpenseReport < ApplicationRecord
  include Fosm::Lifecycle

  belongs_to :submitted_by_user, class_name: "User"
  belongs_to :approved_by_user,  class_name: "User", optional: true

  has_many :expenses, dependent: :nullify

  validates :title,    presence: true
  validates :currency, presence: true

  before_save :recalculate_total

  enum :status, {
    draft:     "draft",
    submitted: "submitted",
    approved:  "approved",
    paid:      "paid",
    rejected:  "rejected"
  }, default: :draft

  # ── FOSM Lifecycle ────────────────────────────────────────────────────────
  # Based on Parolkar's FOSM paper: https://www.parolkar.com/fosm
  lifecycle do
    state :draft,     label: "Draft",     color: "slate",  initial: true
    state :submitted, label: "Submitted", color: "blue"
    state :approved,  label: "Approved",  color: "green"
    state :paid,      label: "Paid",      color: "teal",   terminal: true
    state :rejected,  label: "Rejected",  color: "red",    terminal: true

    event :submit,  from: :draft,      to: :submitted, label: "Submit for Approval"
    event :approve, from: :submitted,  to: :approved,  label: "Approve Report"
    event :pay,     from: :approved,   to: :paid,      label: "Mark as Paid"
    event :reject,  from: :submitted,  to: :rejected,  label: "Reject Report"

    actors :human

    # Guards
    guard :has_expenses, on: :submit,
          description: "Cannot submit a report with no expenses" do |report|
      report.expenses.any?
    end

    guard :all_expenses_reported, on: :submit,
          description: "All expenses must be in reported status before submitting" do |report|
      report.expenses.all?(&:reported?)
    end

    guard :not_approving_own_report, on: :approve,
          description: "Cannot approve your own expense report" do |report, _event, actor|
      actor.nil? || actor.id != report.submitted_by_user_id
    end

    # ── Compound Lifecycle Side Effects ──────────────────────────────────────
    # These are the core of the compound lifecycle pattern: when the report
    # transitions, all contained expenses transition with it.

    side_effect :set_submitted_at, on: :submit,
                description: "Record submission timestamp" do |report, _t|
      report.update!(submitted_at: Time.current)
    end

    side_effect :approve_all_expenses, on: :approve,
                description: "Cascade approval to all contained expenses" do |report, transition|
      report.update!(
        approved_at:        Time.current,
        approved_by_user_id: transition.actor_id
      )
      # The compound lifecycle: approve each expense through its own FOSM lifecycle
      report.expenses.reported.each do |expense|
        expense.approve_from_report!(actor: transition.actor)
      end
    end

    side_effect :notify_submitter_approved, on: :approve,
                description: "Notify submitter that their report was approved" do |report, _t|
      ExpenseMailer.report_approved(report).deliver_later
    end

    side_effect :pay_all_expenses, on: :pay,
                description: "Record payment timestamp on report and all expenses" do |report, _t|
      report.update!(paid_at: Time.current)
      # Update payment timestamp on expenses (they're already approved, just getting paid_at)
      report.expenses.approved.update_all(paid_at: Time.current)
      Fosm::EventBus.publish("expense_report.paid", {
        report_id:    report.id,
        total_cents:  report.total_cents,
        submitted_by: report.submitted_by_user_id
      })
    end

    side_effect :reject_all_expenses, on: :reject,
                description: "Cascade rejection to all submitted expenses, move report to rejected" do |report, transition|
      report.update!(rejected_at: Time.current)
      report.expenses.reported.each do |expense|
        expense.reject_from_report!(actor: transition.actor)
      end
      ExpenseMailer.report_rejected(report, transition.metadata[:rejection_notes]).deliver_later
    end
  end
  # ── End Lifecycle ─────────────────────────────────────────────────────────

  scope :pending_approval, -> { where(status: :submitted) }
  scope :for_user,         ->(user) { where(submitted_by_user: user) }

  def submit!(actor:)
    transition!(:submit, actor: actor)
  end

  def approve!(actor:, notes: nil)
    transition!(:approve, actor: actor, metadata: { notes: notes })
  end

  def pay!(actor:)
    transition!(:pay, actor: actor)
  end

  def reject!(actor:, notes: nil)
    update!(rejection_notes: notes) if notes.present?
    transition!(:reject, actor: actor, metadata: { rejection_notes: notes })
  end

  def add_expense(expense)
    expenses << expense
    recalculate_total
    save!
  end

  def expense_count        = expenses.count
  def total_formatted      = "$#{(total_cents / 100.0).round(2)}"

  private

  def recalculate_total
    self.total_cents = expenses.sum(:amount_cents)
  end
end

# frozen_string_literal: true

class InvoicesController < ApplicationController
  before_action :authenticate_user!
  before_action :set_invoice, only: %i[show edit update send_invoice pay mark_overdue cancel]

  def index
    @invoices     = Invoice.includes(:contact, :line_items).order(created_at: :desc)
    @outstanding  = Invoice.outstanding.sum(:total_cents)
    @overdue      = Invoice.overdue_today.count
  end

  def show
    @line_items  = @invoice.line_items
    @transitions = @invoice.fosm_transitions.order(created_at: :asc)
  end

  def new
    @invoice = Invoice.new(contact_id: params[:contact_id])
    @invoice.line_items.build
  end

  def create
    @invoice = Invoice.new(invoice_params)
    @invoice.created_by_user = current_user

    if @invoice.save
      redirect_to @invoice, notice: "Invoice #{@invoice.invoice_number} created."
    else
      render :new, status: :unprocessable_entity
    end
  end

  def edit
    @invoice.line_items.build if @invoice.draft?
  end

  def update
    if @invoice.update(invoice_params)
      redirect_to @invoice, notice: "Invoice updated."
    else
      render :edit, status: :unprocessable_entity
    end
  end

  def send_invoice
    @invoice.send!(actor: current_user)
    redirect_to @invoice, notice: "Invoice sent to #{@invoice.contact.full_name}."
  rescue Fosm::GuardFailedError => e
    redirect_to @invoice, alert: e.message
  end

  def pay
    @invoice.pay!(
      actor:     current_user,
      method:    params[:payment_method],
      reference: params[:payment_reference]
    )
    redirect_to @invoice, notice: "Invoice marked as paid."
  rescue Fosm::GuardFailedError => e
    redirect_to @invoice, alert: e.message
  end

  def mark_overdue
    @invoice.mark_overdue!(actor: current_user)
    redirect_to @invoice, notice: "Invoice marked as overdue."
  rescue Fosm::GuardFailedError => e
    redirect_to @invoice, alert: e.message
  end

  def cancel
    @invoice.cancel!(actor: current_user)
    redirect_to invoices_path, notice: "Invoice cancelled."
  rescue Fosm::GuardFailedError => e
    redirect_to @invoice, alert: e.message
  end

  private

  def set_invoice
    @invoice = Invoice.find(params[:id])
  end

  def invoice_params
    params.require(:invoice).permit(
      :contact_id, :currency, :due_date, :payment_terms, :notes,
      line_items_attributes: [:id, :description, :quantity, :unit_price_cents, :_destroy]
    )
  end
end

# frozen_string_literal: true

class ExpenseReportsController < ApplicationController
  before_action :authenticate_user!
  before_action :set_report, only: %i[show edit update submit approve reject pay]

  def index
    @my_reports     = ExpenseReport.for_user(current_user).order(created_at: :desc)
    @pending_review = ExpenseReport.pending_approval.includes(:submitted_by_user, :expenses)
                                   .order(submitted_at: :asc) if can_approve_reports?
  end

  def show
    @expenses    = @report.expenses.includes(:submitted_by_user)
    @transitions = @report.fosm_transitions.order(created_at: :asc)
  end

  def new
    @report = ExpenseReport.new(submitted_by_user: current_user)
  end

  def create
    @report = ExpenseReport.new(report_params)
    @report.submitted_by_user = current_user

    if @report.save
      redirect_to @report, notice: "Expense report created."
    else
      render :new, status: :unprocessable_entity
    end
  end

  def edit; end

  def update
    if @report.update(report_params)
      redirect_to @report, notice: "Report updated."
    else
      render :edit, status: :unprocessable_entity
    end
  end

  # ── Lifecycle Actions ─────────────────────────────────────────────────────

  def submit
    @report.submit!(actor: current_user)
    redirect_to @report, notice: "Report submitted for approval."
  rescue Fosm::GuardFailedError => e
    redirect_to @report, alert: e.message
  end

  def approve
    @report.approve!(actor: current_user, notes: params[:approval_notes])
    redirect_to @report, notice: "Report approved. All #{@report.expense_count} expenses approved."
  rescue Fosm::GuardFailedError => e
    redirect_to @report, alert: e.message
  end

  def reject
    @report.reject!(actor: current_user, notes: params[:rejection_notes])
    redirect_to @report, notice: "Report rejected."
  rescue Fosm::GuardFailedError => e
    redirect_to @report, alert: e.message
  end

  def pay
    @report.pay!(actor: current_user)
    redirect_to @report, notice: "Report marked as paid. All expenses updated."
  rescue Fosm::GuardFailedError => e
    redirect_to @report, alert: e.message
  end

  private

  def set_report
    @report = ExpenseReport.find(params[:id])
  end

  def report_params
    params.require(:expense_report).permit(:title, :currency, :notes)
  end

  def can_approve_reports?
    current_user.has_role?(:finance_approver) || current_user.has_role?(:admin)
  end
end

resources :invoices do
  member do
    post :send_invoice
    post :pay
    post :mark_overdue
    post :cancel
  end
end

resources :expenses

resources :expense_reports do
  member do
    post :submit
    post :approve
    post :reject
    post :pay
  end

  resources :expenses, only: %i[index new create]
end

# Background job route for overdue invoice automation
namespace :jobs do
  post :mark_overdue_invoices
end

# frozen_string_literal: true

class MarkOverdueInvoicesJob < ApplicationJob
  queue_as :scheduled

  def perform
    # Find all sent invoices past their due date
    overdue_invoices = Invoice.sent.where("due_date < ?", Date.current)

    overdue_invoices.find_each do |invoice|
      invoice.mark_overdue!(actor: nil)  # system actor
    rescue Fosm::GuardFailedError => e
      Rails.logger.warn "Could not mark invoice #{invoice.id} overdue: #{e.message}"
    end

    Rails.logger.info "Marked #{overdue_invoices.count} invoices as overdue"
  end
end

ModuleSetting.find_or_create_by(module_name: "invoicing") do |setting|
  setting.enabled    = true
  setting.label      = "Invoicing"
  setting.icon       = "receipt"
  setting.sort_order = 40
  setting.config     = {
    default_currency:    "USD",
    default_payment_terms: "Net 30",
    invoice_prefix:      "INV",
    tax_rate_percent:    0,
    overdue_reminder_days: [7, 14, 30],
    auto_mark_overdue:   true
  }
end

ModuleSetting.find_or_create_by(module_name: "expenses") do |setting|
  setting.enabled    = true
  setting.label      = "Expenses"
  setting.icon       = "wallet"
  setting.sort_order = 41
  setting.config     = {
    default_currency: "USD",
    categories:       Expense::CATEGORIES,
    require_receipt:  true,
    approval_roles:   %w[finance_approver admin],
    max_auto_approve_cents: 0   # 0 = no auto-approval
  }
end

# frozen_string_literal: true

module Financial
  class QueryService
    # High-level financial health summary
    def get_summary
      {
        receivables: {
          outstanding_count:    Invoice.outstanding.count,
          outstanding_value:    Invoice.outstanding.sum(:total_cents),
          overdue_count:        Invoice.overdue_today.count,
          overdue_value:        Invoice.overdue_today.sum(:total_cents),
          paid_this_month:      Invoice.paid.where(paid_at: Time.current.all_month).sum(:total_cents),
          draft_count:          Invoice.draft.count
        },
        payables: {
          pending_reports:      ExpenseReport.pending_approval.count,
          pending_total_cents:  ExpenseReport.pending_approval.sum(:total_cents),
          approved_unpaid:      ExpenseReport.approved.count,
          approved_unpaid_value: ExpenseReport.approved.sum(:total_cents),
          draft_expenses:       Expense.draft.count
        }
      }
    end

    # All invoices, optionally filtered by status
    def get_invoices(status: nil, limit: 50)
      scope = Invoice.includes(:contact, :line_items).order(created_at: :desc)
      scope = scope.where(status: status) if status.present?
      scope.limit(limit).map { |inv| serialize_invoice(inv) }
    end

    # Full detail for a single invoice
    def get_invoice_details(invoice_id)
      invoice = Invoice.includes(:contact, :line_items, :fosm_transitions).find(invoice_id)
      serialize_invoice(invoice, include_line_items: true, include_history: true)
    end

    # All overdue invoices with days overdue
    def get_overdue_invoices
      Invoice.overdue_today.includes(:contact).order("due_date ASC").map do |inv|
        serialize_invoice(inv).merge(days_overdue: inv.days_overdue)
      end
    end

    # All expense reports, optionally filtered by status
    def get_expense_reports(status: nil, user_id: nil)
      scope = ExpenseReport.includes(:submitted_by_user, :approved_by_user, :expenses)
                           .order(created_at: :desc)
      scope = scope.where(status: status)       if status.present?
      scope = scope.where(submitted_by_user_id: user_id) if user_id.present?
      scope.map { |r| serialize_report(r) }
    end

    # Full detail for one expense report including all expenses
    def get_expense_report_details(report_id)
      report = ExpenseReport.includes(
        :submitted_by_user, :approved_by_user,
        expenses: :submitted_by_user,
        fosm_transitions: []
      ).find(report_id)

      serialize_report(report, include_expenses: true, include_history: true)
    end

    # Reports pending approval — for finance approvers
    def get_reports_pending_approval
      ExpenseReport.pending_approval
                   .includes(:submitted_by_user, :expenses)
                   .order(submitted_at: :asc)
                   .map { |r| serialize_report(r) }
    end

    # Revenue collected vs. outstanding summary for a date range
    def get_receivables_aging
      {
        current:       Invoice.sent.where("due_date >= ?", Date.current).map { |i| serialize_invoice(i) },
        overdue_0_30:  Invoice.overdue_today.where("due_date >= ?", 30.days.ago).map { |i| serialize_invoice(i) },
        overdue_31_60: Invoice.overdue_today.where(due_date: 60.days.ago..31.days.ago).map { |i| serialize_invoice(i) },
        overdue_60_plus: Invoice.overdue_today.where("due_date < ?", 60.days.ago).map { |i| serialize_invoice(i) }
      }
    end

    private

    def serialize_invoice(invoice, include_line_items: false, include_history: false)
      result = {
        id:              invoice.id,
        invoice_number:  invoice.invoice_number,
        contact:         invoice.contact.full_name,
        status:          invoice.status,
        total_cents:     invoice.total_cents,
        currency:        invoice.currency,
        issue_date:      invoice.issue_date,
        due_date:        invoice.due_date,
        sent_at:         invoice.sent_at,
        paid_at:         invoice.paid_at,
        payment_method:  invoice.payment_method
      }

      if include_line_items
        result[:line_items] = invoice.line_items.map do |li|
          {
            description:      li.description,
            quantity:         li.quantity,
            unit_price_cents: li.unit_price_cents,
            total_cents:      li.total_cents
          }
        end
      end

      if include_history
        result[:transitions] = invoice.fosm_transitions.map do |t|
          { event: t.event, from: t.from_state, to: t.to_state, at: t.created_at, actor: t.actor_type }
        end
      end

      result
    end

    def serialize_report(report, include_expenses: false, include_history: false)
      result = {
        id:             report.id,
        title:          report.title,
        submitted_by:   report.submitted_by_user.full_name,
        approved_by:    report.approved_by_user&.full_name,
        status:         report.status,
        total_cents:    report.total_cents,
        expense_count:  report.expense_count,
        submitted_at:   report.submitted_at,
        approved_at:    report.approved_at,
        paid_at:        report.paid_at,
        rejected_at:    report.rejected_at,
        rejection_notes: report.rejection_notes
      }

      if include_expenses
        result[:expenses] = report.expenses.map do |e|
          {
            id:           e.id,
            description:  e.description,
            category:     e.category,
            amount_cents: e.amount_cents,
            expense_date: e.expense_date,
            status:       e.status,
            has_receipt:  e.receipt.attached?
          }
        end
      end

      if include_history
        result[:transitions] = report.fosm_transitions.map do |t|
          { event: t.event, from: t.from_state, to: t.to_state, at: t.created_at }
        end
      end

      result
    end
  end
end

# frozen_string_literal: true

module Financial
  class QueryTool
    TOOL_DEFINITION = {
      name:        "financial_query",
      description: "Query financial data including invoices, expense reports, receivables aging, and payables. Use this to understand outstanding payments, overdue invoices, pending expense approvals, and financial health summaries.",
      parameters:  {
        type:       "object",
        properties: {
          action: {
            type:        "string",
            description: "The query to perform",
            enum:        %w[
              get_summary
              get_invoices
              get_invoice_details
              get_overdue_invoices
              get_expense_reports
              get_expense_report_details
              get_reports_pending_approval
              get_receivables_aging
            ]
          },
          invoice_id: {
            type:        "integer",
            description: "Required for get_invoice_details"
          },
          report_id: {
            type:        "integer",
            description: "Required for get_expense_report_details"
          },
          status: {
            type:        "string",
            description: "Optional status filter for get_invoices or get_expense_reports"
          },
          user_id: {
            type:        "integer",
            description: "Optional user filter for get_expense_reports"
          }
        },
        required: ["action"]
      }
    }.freeze

    def self.call(action:, invoice_id: nil, report_id: nil, status: nil, user_id: nil)
      service = QueryService.new

      case action
      when "get_summary"                    then service.get_summary
      when "get_invoices"                   then service.get_invoices(status: status)
      when "get_invoice_details"
        raise ArgumentError, "invoice_id required" unless invoice_id
        service.get_invoice_details(invoice_id)
      when "get_overdue_invoices"           then service.get_overdue_invoices
      when "get_expense_reports"            then service.get_expense_reports(status: status, user_id: user_id)
      when "get_expense_report_details"
        raise ArgumentError, "report_id required" unless report_id
        service.get_expense_report_details(report_id)
      when "get_reports_pending_approval"   then service.get_reports_pending_approval
      when "get_receivables_aging"          then service.get_receivables_aging
      else
        raise ArgumentError, "Unknown action: #{action}"
      end
    end
  end
end