class CreateContacts < ActiveRecord::Migration[8.1]
  def change
    create_table :contacts do |t|
      t.references :company,          foreign_key: true
      t.references :created_by_user,  null: false, foreign_key: { to_table: :users }
      t.references :assigned_to_user, foreign_key: { to_table: :users }

      t.string  :first_name,    null: false
      t.string  :last_name,     null: false
      t.string  :email
      t.string  :phone
      t.string  :job_title
      t.string  :linkedin_url
      t.string  :source
      t.string  :status,        null: false, default: "lead"

      t.datetime :qualified_at
      t.datetime :converted_at
      t.datetime :churned_at
      t.text     :churn_reason
      t.datetime :archived_at
      t.text     :archive_reason

      t.text     :notes

      t.timestamps
    end

    add_index :contacts, :status
    add_index :contacts, :email, unique: true, where: "email IS NOT NULL"
    add_index :contacts, [:status, :created_at]
  end
end

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

      t.string  :name,          null: false
      t.integer :value_cents,   null: false, default: 0
      t.string  :currency,      null: false, default: "USD"
      t.string  :status,        null: false, default: "qualifying"

      t.date    :expected_close_date
      t.date    :closed_at

      t.text    :description
      t.string  :loss_reason
      t.text    :loss_notes

      t.datetime :proposed_at
      t.datetime :won_at
      t.datetime :lost_at

      t.timestamps
    end

    add_index :deals, :status
    add_index :deals, [:contact_id, :status]
    add_index :deals, :expected_close_date
    add_index :deals, [:status, :created_at]
  end
end

# frozen_string_literal: true

class Contact < ApplicationRecord
  include Fosm::Lifecycle

  belongs_to :company, optional: true
  belongs_to :created_by_user,  class_name: "User"
  belongs_to :assigned_to_user, class_name: "User", optional: true

  has_many :deals, dependent: :nullify
  has_many :activities, dependent: :destroy

  validates :first_name, presence: true
  validates :last_name,  presence: true
  validates :email, format: { with: URI::MailTo::EMAIL_REGEXP }, allow_blank: true

  enum :status, {
    lead:      "lead",
    qualified: "qualified",
    customer:  "customer",
    partner:   "partner",
    churned:   "churned",
    archived:  "archived"
  }, default: :lead

  # ── FOSM Lifecycle ────────────────────────────────────────────────────────
  # Based on Parolkar's FOSM paper: https://www.parolkar.com/fosm
  lifecycle do
    state :lead,      label: "Lead",      color: "slate",   initial: true
    state :qualified, label: "Qualified", color: "blue"
    state :customer,  label: "Customer",  color: "green"
    state :partner,   label: "Partner",   color: "purple"
    state :churned,   label: "Churned",   color: "orange"
    state :archived,  label: "Archived",  color: "slate",   terminal: true

    event :qualify_lead,        from: :lead,                        to: :qualified, label: "Qualify Lead"
    event :convert_to_customer, from: :qualified,                   to: :customer,  label: "Convert to Customer"
    event :promote_to_partner,  from: :customer,                    to: :partner,   label: "Promote to Partner"
    event :mark_churned,        from: [:customer, :partner],        to: :churned,   label: "Mark as Churned"
    event :archive,             from: [:lead, :qualified, :customer, :partner, :churned],
                                                                    to: :archived,  label: "Archive Contact"

    actors :human

    # Guards
    guard :has_email_for_qualification, on: :qualify_lead,
          description: "Contact must have an email address before qualifying" do |contact|
      contact.email.present?
    end

    guard :has_active_deals_for_conversion, on: :convert_to_customer,
          description: "Contact must have at least one won deal to convert to customer" do |contact|
      contact.deals.where(status: :won).exists?
    end

    # Side effects — create Activity records on every transition
    side_effect :record_qualification_activity, on: :qualify_lead,
                description: "Record qualification activity and timestamp" do |contact, transition|
      contact.update!(qualified_at: Time.current)
      contact.activities.create!(
        activity_type: "stage_change",
        description:   "Contact qualified by #{transition.actor&.full_name || "system"}",
        occurred_at:   Time.current,
        created_by_user_id: transition.actor_id
      )
    end

    side_effect :record_conversion_activity, on: :convert_to_customer,
                description: "Record customer conversion and timestamp" do |contact, transition|
      contact.update!(converted_at: Time.current)
      contact.activities.create!(
        activity_type: "stage_change",
        description:   "Converted to customer by #{transition.actor&.full_name || "system"}",
        occurred_at:   Time.current,
        created_by_user_id: transition.actor_id
      )
    end

    side_effect :record_churn_activity, on: :mark_churned,
                description: "Record churn timestamp and nullify open deals" do |contact, transition|
      contact.update!(churned_at: Time.current)
      contact.activities.create!(
        activity_type: "stage_change",
        description:   "Marked as churned",
        occurred_at:   Time.current,
        created_by_user_id: transition.actor_id
      )
      # Publish churn event for downstream handling
      Fosm::EventBus.publish("contact.churned", {
        contact_id: contact.id,
        actor_id:   transition.actor_id
      })
    end
  end
  # ── End Lifecycle ─────────────────────────────────────────────────────────

  scope :active_contacts, -> { where.not(status: :archived) }
  scope :pipeline,        -> { where(status: %w[lead qualified]) }

  def full_name = "#{first_name} #{last_name}"

  def qualify!(actor:)
    transition!(:qualify_lead, actor: actor)
  end

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

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

  def churn!(actor:, reason: nil)
    update!(churn_reason: reason) if reason.present?
    transition!(:mark_churned, actor: actor)
  end

  def archive!(actor:, reason: nil)
    update!(archived_at: Time.current, archive_reason: reason)
    transition!(:archive, actor: actor)
  end

  def open_deals
    deals.where.not(status: %w[won lost])
  end

  def won_deals
    deals.where(status: :won)
  end
end

# frozen_string_literal: true

class Deal < ApplicationRecord
  include Fosm::Lifecycle

  belongs_to :contact
  belongs_to :created_by_user,  class_name: "User"
  belongs_to :assigned_to_user, class_name: "User", optional: true

  validates :name,        presence: true
  validates :value_cents, numericality: { greater_than_or_equal_to: 0 }

  enum :status, {
    qualifying:  "qualifying",
    proposal:    "proposal",
    negotiation: "negotiation",
    won:         "won",
    lost:        "lost"
  }, default: :qualifying

  # ── FOSM Lifecycle ────────────────────────────────────────────────────────
  # Based on Parolkar's FOSM paper: https://www.parolkar.com/fosm
  lifecycle do
    state :qualifying,  label: "Qualifying",  color: "slate",  initial: true
    state :proposal,    label: "Proposal",    color: "blue"
    state :negotiation, label: "Negotiation", color: "amber"
    state :won,         label: "Won",         color: "green",  terminal: true
    state :lost,        label: "Lost",        color: "red",    terminal: true

    event :propose,    from: :qualifying,                   to: :proposal,    label: "Send Proposal"
    event :negotiate,  from: :proposal,                     to: :negotiation, label: "Enter Negotiation"
    event :win,        from: :negotiation,                  to: :won,         label: "Mark as Won"
    event :lose,       from: [:qualifying, :proposal, :negotiation], to: :lost, label: "Mark as Lost"

    actors :human

    # Cross-model guard: can't win a deal if the contact is churned
    guard :contact_not_churned, on: :win,
          description: "Cannot win a deal if the associated contact is churned" do |deal|
      !deal.contact.churned?
    end

    guard :contact_not_archived, on: [:propose, :negotiate, :win],
          description: "Cannot advance a deal if the associated contact is archived" do |deal|
      !deal.contact.archived?
    end

    # Side effects
    side_effect :record_proposal_sent, on: :propose,
                description: "Record proposal timestamp" do |deal, _t|
      deal.update!(proposed_at: Time.current)
    end

    side_effect :record_close_won, on: :win,
                description: "Record won timestamp and notify contact" do |deal, transition|
      deal.update!(won_at: Time.current, closed_at: Date.current)
      Fosm::EventBus.publish("deal.won", {
        deal_id:    deal.id,
        contact_id: deal.contact_id,
        value_cents: deal.value_cents,
        actor_id:   transition.actor_id
      })
    end

    side_effect :record_close_lost, on: :lose,
                description: "Record lost timestamp" do |deal, _t|
      deal.update!(lost_at: Time.current, closed_at: Date.current)
    end
  end
  # ── End Lifecycle ─────────────────────────────────────────────────────────

  scope :open,           -> { where.not(status: %w[won lost]) }
  scope :closed_won,     -> { where(status: :won) }
  scope :closed_lost,    -> { where(status: :lost) }
  scope :closing_soon,   -> { open.where("expected_close_date <= ?", 30.days.from_now) }

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

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

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

  def lose!(actor:, reason: nil, notes: nil)
    update!(loss_reason: reason, loss_notes: notes) if reason.present?
    transition!(:lose, actor: actor)
  end

  def value_formatted
    Money.new(value_cents, currency).format
  rescue
    "$#{value_cents / 100.0}"
  end
end

# frozen_string_literal: true

class ContactsController < ApplicationController
  before_action :authenticate_user!
  before_action :set_contact, only: %i[show edit update qualify convert promote churn archive]

  def index
    @contacts = Contact.active_contacts
                       .includes(:company, :assigned_to_user, :deals)
                       .order(created_at: :desc)

    # Support filtering by status
    @contacts = @contacts.where(status: params[:status]) if params[:status].present?
  end

  def show
    @deals      = @contact.deals.order(created_at: :desc)
    @activities = @contact.activities.order(occurred_at: :desc)
    @transitions = @contact.fosm_transitions.order(created_at: :asc)
  end

  def new
    @contact = Contact.new
  end

  def create
    @contact = Contact.new(contact_params)
    @contact.created_by_user = current_user

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

  def edit; end

  def update
    if @contact.update(contact_params)
      redirect_to @contact, notice: "Contact updated."
    else
      render :edit, status: :unprocessable_entity
    end
  end

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

  def qualify
    @contact.qualify!(actor: current_user)
    redirect_to @contact, notice: "#{@contact.full_name} qualified."
  rescue Fosm::GuardFailedError => e
    redirect_to @contact, alert: e.message
  end

  def convert
    @contact.convert_to_customer!(actor: current_user)
    redirect_to @contact, notice: "#{@contact.full_name} converted to customer."
  rescue Fosm::GuardFailedError => e
    redirect_to @contact, alert: e.message
  end

  def promote
    @contact.promote_to_partner!(actor: current_user)
    redirect_to @contact, notice: "#{@contact.full_name} promoted to partner."
  rescue Fosm::GuardFailedError => e
    redirect_to @contact, alert: e.message
  end

  def churn
    @contact.churn!(actor: current_user, reason: params[:churn_reason])
    redirect_to @contact, notice: "Contact marked as churned."
  rescue Fosm::GuardFailedError => e
    redirect_to @contact, alert: e.message
  end

  def archive
    @contact.archive!(actor: current_user, reason: params[:archive_reason])
    redirect_to contacts_path, notice: "Contact archived."
  rescue Fosm::GuardFailedError => e
    redirect_to @contact, alert: e.message
  end

  private

  def set_contact
    @contact = Contact.find(params[:id])
  end

  def contact_params
    params.require(:contact).permit(
      :first_name, :last_name, :email, :phone, :job_title,
      :company_id, :linkedin_url, :source, :assigned_to_user_id, :notes
    )
  end
end

# frozen_string_literal: true

class DealsController < ApplicationController
  before_action :authenticate_user!
  before_action :set_deal, only: %i[show edit update propose negotiate win lose]

  def index
    @pipeline = {
      qualifying:  Deal.qualifying.includes(:contact, :assigned_to_user).order(expected_close_date: :asc),
      proposal:    Deal.proposal.includes(:contact, :assigned_to_user).order(expected_close_date: :asc),
      negotiation: Deal.negotiation.includes(:contact, :assigned_to_user).order(expected_close_date: :asc),
      won:         Deal.closed_won.limit(10).order(won_at: :desc),
      lost:        Deal.closed_lost.limit(10).order(lost_at: :desc)
    }

    @pipeline_value = Deal.open.sum(:value_cents)
  end

  def show
    @contact    = @deal.contact
    @transitions = @deal.fosm_transitions.order(created_at: :asc)
  end

  def new
    @deal = Deal.new(contact_id: params[:contact_id])
  end

  def create
    @deal = Deal.new(deal_params)
    @deal.created_by_user = current_user

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

  def edit; end

  def update
    if @deal.update(deal_params)
      redirect_to @deal, notice: "Deal updated."
    else
      render :edit, status: :unprocessable_entity
    end
  end

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

  def propose
    @deal.propose!(actor: current_user)
    respond_to do |format|
      format.html { redirect_to deals_path, notice: "Deal moved to Proposal." }
      format.turbo_stream
    end
  rescue Fosm::GuardFailedError => e
    respond_to do |format|
      format.html { redirect_to @deal, alert: e.message }
      format.turbo_stream { render turbo_stream: turbo_stream.replace("deal_#{@deal.id}_alert", partial: "shared/alert", locals: { message: e.message }) }
    end
  end

  def negotiate
    @deal.negotiate!(actor: current_user)
    respond_to do |format|
      format.html { redirect_to deals_path, notice: "Deal moved to Negotiation." }
      format.turbo_stream
    end
  rescue Fosm::GuardFailedError => e
    respond_to do |format|
      format.html { redirect_to @deal, alert: e.message }
      format.turbo_stream { render turbo_stream: turbo_stream.replace("deal_#{@deal.id}_alert", partial: "shared/alert", locals: { message: e.message }) }
    end
  end

  def win
    @deal.win!(actor: current_user)
    respond_to do |format|
      format.html { redirect_to deals_path, notice: "Deal won. 🎉" }
      format.turbo_stream
    end
  rescue Fosm::GuardFailedError => e
    respond_to do |format|
      format.html { redirect_to @deal, alert: e.message }
      format.turbo_stream { render turbo_stream: turbo_stream.replace("deal_#{@deal.id}_alert", partial: "shared/alert", locals: { message: e.message }) }
    end
  end

  def lose
    @deal.lose!(actor: current_user, reason: params[:loss_reason], notes: params[:loss_notes])
    respond_to do |format|
      format.html { redirect_to deals_path, notice: "Deal marked as lost." }
      format.turbo_stream
    end
  rescue Fosm::GuardFailedError => e
    respond_to do |format|
      format.html { redirect_to @deal, alert: e.message }
      format.turbo_stream { render turbo_stream: turbo_stream.replace("deal_#{@deal.id}_alert", partial: "shared/alert", locals: { message: e.message }) }
    end
  end

  private

  def set_deal
    @deal = Deal.find(params[:id])
  end

  def deal_params
    params.require(:deal).permit(
      :contact_id, :name, :value_cents, :currency,
      :expected_close_date, :description, :assigned_to_user_id
    )
  end
end

resources :contacts do
  member do
    post :qualify
    post :convert
    post :promote
    post :churn
    post :archive
  end
end

resources :deals do
  member do
    post :propose
    post :negotiate
    post :win
    post :lose
  end
end

ModuleSetting.find_or_create_by(module_name: "crm") do |setting|
  setting.enabled    = true
  setting.label      = "CRM"
  setting.icon       = "users"
  setting.sort_order = 20
  setting.config     = {
    lead_sources: %w[website referral event cold_outreach partner inbound],
    require_email_for_qualification: true,
    require_won_deal_for_conversion: true,
    deal_currency:    "USD",
    pipeline_stages:  %w[qualifying proposal negotiation],
    loss_reasons:     %w[price timing competitor no_budget no_need],
    activity_types:   %w[call email meeting demo proposal stage_change note]
  }
end

# frozen_string_literal: true

module Crm
  class QueryService
    # High-level summary of CRM health
    def get_summary
      {
        contacts: {
          total:     Contact.count,
          leads:     Contact.lead.count,
          qualified: Contact.qualified.count,
          customers: Contact.customer.count,
          partners:  Contact.partner.count,
          churned:   Contact.churned.count,
          archived:  Contact.archived.count
        },
        pipeline: {
          total_open_deals:  Deal.open.count,
          pipeline_value:    Deal.open.sum(:value_cents),
          qualifying:        Deal.qualifying.count,
          proposal:          Deal.proposal.count,
          negotiation:       Deal.negotiation.count,
          closing_soon:      Deal.closing_soon.count
        },
        recent_wins: {
          this_month_count:   Deal.closed_won.where(won_at: Time.current.all_month).count,
          this_month_value:   Deal.closed_won.where(won_at: Time.current.all_month).sum(:value_cents)
        }
      }
    end

    # Returns all active contacts with their deal counts
    def get_all_contacts(status: nil, limit: 50)
      scope = Contact.active_contacts.includes(:company, :deals).order(created_at: :desc)
      scope = scope.where(status: status) if status.present?
      scope.limit(limit).map { |c| serialize_contact(c) }
    end

    # Returns full detail for one contact including deals and activity
    def get_contact_details(contact_id)
      contact = Contact.includes(
        :company, :assigned_to_user,
        :activities,
        deals: :fosm_transitions,
        fosm_transitions: []
      ).find(contact_id)

      serialize_contact(contact,
        include_deals:      true,
        include_activities: true,
        include_history:    true
      )
    end

    # Returns the full pipeline grouped by stage
    def get_pipeline_summary
      stages = %w[qualifying proposal negotiation]
      result = {}

      stages.each do |stage|
        deals = Deal.where(status: stage).includes(:contact).order(expected_close_date: :asc)
        result[stage] = {
          count:        deals.count,
          total_value:  deals.sum(:value_cents),
          deals:        deals.map { |d| serialize_deal(d) }
        }
      end

      result[:closing_this_month] = Deal.open
                                        .where("expected_close_date <= ?", Date.current.end_of_month)
                                        .map { |d| serialize_deal(d) }

      result
    end

    # Returns contacts at risk: recently qualified leads with no deals, long-stalled deals
    def get_contacts_needing_attention
      stalled_leads = Contact.qualified
                              .where("qualified_at < ?", 14.days.ago)
                              .where.missing(:deals)

      overdue_deals = Deal.open
                           .where("expected_close_date < ?", Date.current)

      {
        stalled_leads: stalled_leads.map { |c| serialize_contact(c) },
        overdue_deals: overdue_deals.map { |d| serialize_deal(d) }
      }
    end

    # Returns churn metrics
    def get_churn_summary(since: 90.days.ago)
      churned_contacts = Contact.churned.where("churned_at >= ?", since)

      {
        churned_count:      churned_contacts.count,
        churned_contacts:   churned_contacts.map { |c| serialize_contact(c) },
        churn_reasons:      churned_contacts.group(:churn_reason).count,
        lost_deal_count:    Deal.closed_lost.where("lost_at >= ?", since).count,
        lost_deal_value:    Deal.closed_lost.where("lost_at >= ?", since).sum(:value_cents),
        lost_deal_reasons:  Deal.closed_lost.where("lost_at >= ?", since).group(:loss_reason).count
      }
    end

    private

    def serialize_contact(contact, include_deals: false, include_activities: false, include_history: false)
      result = {
        id:            contact.id,
        full_name:     contact.full_name,
        email:         contact.email,
        status:        contact.status,
        company:       contact.company&.name,
        job_title:     contact.job_title,
        source:        contact.source,
        qualified_at:  contact.qualified_at,
        converted_at:  contact.converted_at,
        churned_at:    contact.churned_at,
        open_deals:    contact.open_deals.count,
        won_deals:     contact.won_deals.count
      }

      if include_deals
        result[:deals] = contact.deals.map { |d| serialize_deal(d) }
      end

      if include_activities
        result[:recent_activities] = contact.activities.order(occurred_at: :desc).limit(10).map do |a|
          { type: a.activity_type, description: a.description, at: a.occurred_at }
        end
      end

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

      result
    end

    def serialize_deal(deal)
      {
        id:                   deal.id,
        name:                 deal.name,
        contact:              deal.contact.full_name,
        contact_status:       deal.contact.status,
        status:               deal.status,
        value_cents:          deal.value_cents,
        expected_close_date:  deal.expected_close_date,
        proposed_at:          deal.proposed_at,
        won_at:               deal.won_at,
        lost_at:              deal.lost_at,
        loss_reason:          deal.loss_reason
      }
    end
  end
end

# frozen_string_literal: true

module Crm
  class QueryTool
    TOOL_DEFINITION = {
      name:        "crm_query",
      description: "Query CRM data including contacts, deals, pipeline health, and churn metrics. Use this to understand the current sales pipeline, find contacts needing attention, or get summary statistics.",
      parameters:  {
        type:       "object",
        properties: {
          action: {
            type:        "string",
            description: "The query to perform",
            enum:        %w[
              get_summary
              get_all_contacts
              get_contact_details
              get_pipeline_summary
              get_contacts_needing_attention
              get_churn_summary
            ]
          },
          contact_id: {
            type:        "integer",
            description: "Required for get_contact_details"
          },
          status: {
            type:        "string",
            description: "Optional status filter for get_all_contacts",
            enum:        %w[lead qualified customer partner churned]
          }
        },
        required: ["action"]
      }
    }.freeze

    def self.call(action:, contact_id: nil, status: nil)
      service = QueryService.new

      case action
      when "get_summary"                    then service.get_summary
      when "get_all_contacts"               then service.get_all_contacts(status: status)
      when "get_contact_details"
        raise ArgumentError, "contact_id required" unless contact_id
        service.get_contact_details(contact_id)
      when "get_pipeline_summary"           then service.get_pipeline_summary
      when "get_contacts_needing_attention" then service.get_contacts_needing_attention
      when "get_churn_summary"              then service.get_churn_summary
      else
        raise ArgumentError, "Unknown action: #{action}"
      end
    end
  end
end