class CreateCompanies < ActiveRecord::Migration[8.1]
  def change
    create_table :companies do |t|
      t.string  :name,                 null: false
      t.string  :registration_number
      t.string  :registration_country, default: "SG"
      t.string  :status,               null: false, default: "prospect"
      t.string  :industry
      t.string  :website
      t.string  :phone
      t.text    :address
      t.string  :source               # "manual", "sec_edgar", "sgx", "csv_import"
      t.string  :source_identifier    # external ID from source system
      t.text    :suspension_reason
      t.datetime :activated_at
      t.datetime :suspended_at
      t.datetime :dissolved_at

      t.timestamps
    end

    add_index :companies, :status
    add_index :companies, :registration_number
    add_index :companies, :registration_country
    add_index :companies, [:source, :source_identifier], unique: true, where: "source_identifier IS NOT NULL"

    # Users and contacts belong to a company
    add_reference :users,    :company, foreign_key: true, index: true
    add_reference :contacts, :company, foreign_key: true, index: true
  end
end

# frozen_string_literal: true

class Company < ApplicationRecord
  include Fosm::Lifecycle

  has_many :users,    dependent: :nullify
  has_many :contacts, dependent: :nullify

  validates :name, presence: true
  validates :source_identifier,
            uniqueness: { scope: :source },
            allow_blank: true

  validates :registration_number,
            presence: true,
            if: -> { active? || activation_attempted? }

  # Based on Parolkar's FOSM paper: https://www.parolkar.com/fosm
  enum :status, {
    prospect:  "prospect",
    active:    "active",
    suspended: "suspended",
    dissolved: "dissolved"
  }, default: :prospect

  lifecycle do
    state :prospect,  label: "Prospect",  color: "slate",  initial: true
    state :active,    label: "Active",    color: "green"
    state :suspended, label: "Suspended", color: "amber"
    state :dissolved, label: "Dissolved", color: "red",    terminal: true

    event :activate, from: [:prospect, :suspended], to: :active,    label: "Activate"
    event :suspend,  from: :active,                 to: :suspended, label: "Suspend"
    event :dissolve, from: [:prospect, :active, :suspended],
                     to: :dissolved, label: "Dissolve"

    actors :human, :system

    # Guards
    guard :has_registration_number, on: :activate,
          description: "Registration number must be present to activate" do |company|
      company.registration_number.present?
    end

    # Side effects
    side_effect :notify_team_on_suspension, on: :suspend,
                description: "Notify account owners when company is suspended" do |company, _t|
      account_owners = User.where(company: company).where(role: "admin")
      account_owners.each do |user|
        CompanyMailer.suspension_notification(company, user).deliver_later
      end
      company.update!(suspended_at: Time.current, suspension_reason: company.suspension_reason)
    end

    side_effect :record_activation_timestamp, on: :activate,
                description: "Record when company became active" do |company, _t|
      company.update!(activated_at: Time.current)
    end

    side_effect :record_dissolution_timestamp, on: :dissolve,
                description: "Record when company was dissolved" do |company, _t|
      company.update!(dissolved_at: Time.current)
    end
  end

  scope :active_companies,   -> { where(status: :active) }
  scope :prospects,          -> { where(status: :prospect) }
  scope :from_source,        ->(src) { where(source: src) }
  scope :in_country,         ->(country) { where(registration_country: country) }
  scope :imported,           -> { where.not(source: "manual") }

  # Called during bulk import — does not fire lifecycle events
  # The company is created directly in prospect state, which is fine:
  # FOSM records the _create transition automatically.
  def self.import_from_row!(row, source:)
    find_or_initialize_by(source: source, source_identifier: row[:source_identifier]).tap do |company|
      company.name                 = row[:name]
      company.registration_number  = row[:registration_number]
      company.registration_country = row[:registration_country] || "SG"
      company.industry             = row[:industry]
      company.website              = row[:website]
      company.source               = source
      company.save!
    end
  end

  # Scoped query helpers for multi-tenancy
  def users_with_access
    users.active
  end

  def suspended_user_count
    users.where(status: "inactive").count
  end

  private

  def activation_attempted?
    @activation_attempted ||= false
  end
end

# frozen_string_literal: true

class CompaniesController < ApplicationController
  before_action :authenticate_user!
  before_action :require_admin!, only: %i[destroy activate suspend dissolve impersonate]
  before_action :set_company,    only: %i[show edit update destroy activate suspend dissolve]

  def index
    @companies = Company.includes(:users, :contacts)
                         .order(name: :asc)
    @companies = @companies.where(status: params[:status])         if params[:status].present?
    @companies = @companies.in_country(params[:country])           if params[:country].present?
    @companies = @companies.from_source(params[:source])           if params[:source].present?
    @companies = @companies.where("name ILIKE ?", "%#{params[:q]}%") if params[:q].present?

    @total_count      = Company.count
    @active_count     = Company.active_companies.count
    @prospect_count   = Company.prospects.count
    @suspended_count  = Company.where(status: :suspended).count

    @companies = @companies.page(params[:page]).per(50)
  end

  def show
    @users          = @company.users.order(name: :asc)
    @contacts       = @company.contacts.order(name: :asc)
    @history        = @company.lifecycle_history
    @available_events = @company.available_events
  end

  def new
    @company = Company.new(registration_country: "SG", source: "manual")
  end

  def create
    @company = Company.new(company_params.merge(source: "manual"))
    if @company.save
      redirect_to @company, notice: "Company created."
    else
      render :new, status: :unprocessable_entity
    end
  end

  def update
    if @company.update(company_params)
      redirect_to @company, notice: "Company updated."
    else
      render :edit, status: :unprocessable_entity
    end
  end

  def destroy
    @company.destroy
    redirect_to companies_path, notice: "Company deleted."
  end

  # ── Transition actions ──────────────────────────────────────────────────────

  def activate
    @company.transition!(:activate, actor: current_user)
    redirect_to @company, notice: "Company activated."
  rescue Fosm::TransitionService::GuardFailed => e
    redirect_to @company, alert: "Cannot activate: #{e.message}"
  end

  def suspend
    @company.assign_attributes(suspension_reason: params[:suspension_reason])
    @company.transition!(:suspend, actor: current_user)
    redirect_to @company, notice: "Company suspended. Account owners notified."
  end

  def dissolve
    @company.transition!(:dissolve, actor: current_user)
    redirect_to @company, notice: "Company marked as dissolved."
  end

  # ── Admin impersonation ─────────────────────────────────────────────────────

  def impersonate
    company = Company.find(params[:id])
    user    = company.users.find(params[:user_id])

    session[:impersonating_user_id]      = user.id
    session[:impersonating_company_id]   = company.id
    session[:impersonation_origin_user_id] = current_user.id

    redirect_to root_path, notice: "Now viewing as #{user.email} (#{company.name}). #{view_context.link_to('Stop impersonating', stop_impersonation_path, method: :delete)}".html_safe
  end

  def stop_impersonation
    origin_id = session.delete(:impersonation_origin_user_id)
    session.delete(:impersonating_user_id)
    session.delete(:impersonating_company_id)

    if origin_id
      redirect_to root_path, notice: "Returned to your account."
    else
      redirect_to root_path
    end
  end

  private

  def set_company
    @company = Company.find(params[:id])
  end

  def company_params
    params.require(:company).permit(
      :name, :registration_number, :registration_country,
      :industry, :website, :phone, :address
    )
  end
end

resources :companies do
  member do
    post   :activate
    post   :suspend
    post   :dissolve
    post   :impersonate
  end
end

delete  '/impersonation', to: 'companies#stop_impersonation', as: :stop_impersonation

# frozen_string_literal: true

namespace :companies do
  desc "Import companies from a CSV file. Usage: rake companies:import SOURCE=sgx FILE=path/to/companies.csv"
  task import: :environment do
    source   = ENV.fetch("SOURCE", "csv_import")
    filename = ENV.fetch("FILE")  { abort "ERROR: FILE= is required. Usage: rake companies:import FILE=path/to/file.csv" }

    abort "ERROR: File not found: #{filename}" unless File.exist?(filename)

    require "csv"

    puts "Importing companies from #{filename} (source: #{source})..."

    total     = 0
    created   = 0
    updated   = 0
    skipped   = 0
    errored   = 0

    CSV.foreach(filename, headers: true, encoding: "UTF-8") do |row|
      total += 1

      # Normalize the row — handle different CSV column name conventions
      normalized = {
        name:                 row["name"]                 || row["company_name"]   || row["Company Name"],
        registration_number:  row["registration_number"]  || row["reg_no"]         || row["Reg No"],
        registration_country: row["registration_country"] || row["country"]        || row["Country"] || "SG",
        industry:             row["industry"]             || row["sector"]         || row["Industry"],
        website:              row["website"]              || row["Website"],
        source_identifier:    row["source_identifier"]    || row["id"]             || row["CIK"] || row["stock_code"],
      }

      next (skipped += 1) if normalized[:name].blank?

      ActiveRecord::Base.transaction do
        was_new = Company.find_by(source: source, source_identifier: normalized[:source_identifier]).nil?
        Company.import_from_row!(normalized, source: source)
        was_new ? (created += 1) : (updated += 1)
      end

    rescue ActiveRecord::RecordInvalid => e
      errored += 1
      warn "  Row #{total}: #{e.message} (#{normalized[:name]})"
    rescue StandardError => e
      errored += 1
      warn "  Row #{total}: Unexpected error: #{e.message}"
    end

    puts "\nImport complete."
    puts "  Total rows: #{total}"
    puts "  Created:    #{created}"
    puts "  Updated:    #{updated}"
    puts "  Skipped:    #{skipped} (blank name)"
    puts "  Errors:     #{errored}"
    puts "\nAll #{created} new companies start in 'prospect' state."
    puts "Run 'rails db:seed' or use the UI to activate them as relationships form."
  end

  desc "Import SGX-listed companies from the Singapore Exchange CSV"
  task import_sgx: :environment do
    ENV["SOURCE"] = "sgx"
    ENV["FILE"]   ||= Rails.root.join("db", "seeds", "sgx_companies.csv").to_s
    Rake::Task["companies:import"].invoke
  end

  desc "Show import statistics"
  task stats: :environment do
    puts "\nCompany Import Statistics"
    puts "─" * 40
    Company.group(:source).count.sort_by { |_, v| -v }.each do |source, count|
      puts "  #{source.ljust(20)} #{count}"
    end
    puts "─" * 40
    puts "  Total: #{Company.count}"
    puts "\nBy status:"
    Company.group(:status).count.each do |status, count|
      puts "  #{status.ljust(20)} #{count}"
    end
  end
end

# frozen_string_literal: true

class ApplicationController < ActionController::Base
  before_action :authenticate_user!
  before_action :set_current_company

  helper_method :current_user, :impersonating?, :impersonated_user, :original_admin

  # Override Devise's current_user to support impersonation
  def current_user
    if session[:impersonating_user_id].present?
      @impersonated_user ||= User.find_by(id: session[:impersonating_user_id])
    else
      super
    end
  end

  def impersonating?
    session[:impersonating_user_id].present?
  end

  def impersonated_user
    return nil unless impersonating?
    @impersonated_user ||= User.find_by(id: session[:impersonating_user_id])
  end

  def original_admin
    return nil unless impersonating?
    User.find_by(id: session[:impersonation_origin_user_id])
  end

  private

  def set_current_company
    if session[:impersonating_company_id].present?
      @current_company = Company.find_by(id: session[:impersonating_company_id])
    elsif current_user&.company_id.present?
      @current_company = current_user.company
    end
  end

  def require_admin!
    redirect_to root_path, alert: "Access denied." unless original_admin_or_current_admin?
  end

  def original_admin_or_current_admin?
    if impersonating?
      User.find_by(id: session[:impersonation_origin_user_id])&.admin?
    else
      current_user&.admin?
    end
  end
end

# frozen_string_literal: true

class CompaniesQueryService
  def self.distribution
    FosmTransition.state_distribution("Company")
  end

  def self.recently_activated(days: 30)
    Company.active_companies
           .where("activated_at >= ?", days.days.ago)
           .order(activated_at: :desc)
           .limit(20)
           .map { |c| { id: c.id, name: c.name, activated_at: c.activated_at, country: c.registration_country } }
  end

  def self.prospects_without_registration
    Company.prospects
           .where(registration_number: [nil, ""])
           .count
  end

  def self.by_source
    Company.group(:source).count
  end

  def self.summary_for_bot
    dist = distribution
    {
      prospect:   dist["prospect"].to_i,
      active:     dist["active"].to_i,
      suspended:  dist["suspended"].to_i,
      dissolved:  dist["dissolved"].to_i,
      total:      Company.count,
      by_source:  by_source,
      prospects_unregistered: prospects_without_registration
    }
  end

  def self.find_by_name(query)
    Company.where("name ILIKE ?", "%#{query}%")
           .limit(10)
           .map { |c| { id: c.id, name: c.name, status: c.status, registration_number: c.registration_number } }
  end

  def self.avg_time_prospect_to_active
    FosmTransition.avg_time_in_state("Company", :prospect)
  end
end

# frozen_string_literal: true

class CompaniesQueryTool
  DEFINITION = {
    name:        "query_companies",
    description: "Query the companies registry: count by lifecycle state, find companies by name, " \
                 "check recently activated companies, get source distribution. " \
                 "Use for: 'how many active companies do we have', " \
                 "'find company named Acme', 'which companies were activated this month'.",
    parameters:  {
      type:       "object",
      properties: {
        action: {
          type:        "string",
          enum:        %w[summary distribution recently_activated find_by_name by_source avg_prospect_time],
          description: "The query action to perform"
        },
        query: {
          type:        "string",
          description: "Search term for find_by_name action"
        },
        days: {
          type:        "integer",
          description: "Number of days for recently_activated (default 30)"
        }
      },
      required: ["action"]
    }
  }.freeze

  def self.call(action:, query: nil, days: 30, **)
    case action
    when "summary"
      CompaniesQueryService.summary_for_bot.to_json
    when "distribution"
      CompaniesQueryService.distribution.to_json
    when "recently_activated"
      CompaniesQueryService.recently_activated(days: days.to_i).to_json
    when "find_by_name"
      CompaniesQueryService.find_by_name(query.to_s).to_json
    when "by_source"
      CompaniesQueryService.by_source.to_json
    when "avg_prospect_time"
      secs = CompaniesQueryService.avg_time_prospect_to_active
      { avg_seconds: secs, avg_days: secs ? (secs / 86400.0).round(1) : nil }.to_json
    else
      { error: "Unknown action: #{action}" }.to_json
    end
  end
end

# db/seeds.rb
ModuleSetting.find_or_create_by!(module_name: "companies") do |m|
  m.display_name = "Companies"
  m.enabled      = true
  m.icon         = "building-office"
  m.description  = "Track company relationships from prospect through active lifecycle."
end

# What has Alice done in the system this week?
FosmTransition
  .where(actor_type: "User", actor_id: alice.id)
  .where(created_at: 1.week.ago..)
  .order(created_at: :desc)
  .map { |t| "#{t.event} on #{t.object_type} ##{t.object_id}: #{t.from_state} → #{t.to_state}" }

# What's the lifecycle velocity of our invoicing process?
{
  draft_to_sent:     FosmTransition.avg_time_in_state("Invoice", :draft),
  sent_to_paid:      FosmTransition.avg_time_in_state("Invoice", :sent),
  overdue_rate:      Invoice.where(status: :overdue).count.to_f / Invoice.where.not(status: :draft).count * 100
}

# How many transitions happened across the entire system today?
FosmTransition.where(created_at: Date.current.all_day).count