class CreateNdas < ActiveRecord::Migration[8.1]
  def change
    create_table :ndas do |t|
      t.references :nda_template,       null: false, foreign_key: true
      t.references :created_by_user,    null: false, foreign_key: { to_table: :users }
      t.references :external_user,      null: false, foreign_key: { to_table: :users }
      t.date    :effective_date,         null: false
      t.integer :confidentiality_period_months, default: 24, null: false
      t.string  :jurisdiction,           default: "State of Delaware, USA", null: false
      t.string  :status,                 default: "draft", null: false
      t.datetime :owner_signed_at
      t.references :owner_signed_by_user, foreign_key: { to_table: :users }
      t.string  :owner_signature
      t.datetime :counterparty_signed_at
      t.string  :counterparty_signature
      t.string  :counterparty_ip_address
      t.string  :signing_token
      t.datetime :signing_token_expires_at
      t.datetime :sent_at
      t.text    :notes

      t.timestamps
    end

    add_index :ndas, :status
    add_index :ndas, :signing_token, unique: true
    add_index :ndas, :signing_token_expires_at
  end
end

# frozen_string_literal: true

class Nda < ApplicationRecord
  include Fosm::Lifecycle

  belongs_to :nda_template, optional: true
  belongs_to :created_by_user, class_name: "User"
  belongs_to :external_user
  belongs_to :owner_signed_by_user, class_name: "User", optional: true

  has_one_attached :custom_document
  has_many :disclosure_documents, class_name: "NdaDisclosureDocument", dependent: :destroy

  validates :effective_date,               presence: true
  validates :confidentiality_period_months, presence: true, numericality: { greater_than: 0 }
  validates :jurisdiction,                 presence: true
  validates :signing_token,                uniqueness: true, allow_nil: true
  validate  :template_or_custom_document_required

  # Rails enum: DB queries and backward compatibility
  enum :status, {
    draft:             "draft",
    sent:              "sent",
    partially_signed:  "partially_signed",
    executed:          "executed",
    expired:           "expired",
    cancelled:         "cancelled"
  }, default: :draft

  # ── FOSM Lifecycle ──────────────────────────────────────────────────────────
  # Based on Parolkar's FOSM paper: https://www.parolkar.com/fosm
  lifecycle do
    # States
    state :draft,            label: "Draft",                 color: "slate",  initial: true
    state :sent,             label: "Sent to Counterparty",  color: "blue"
    state :partially_signed, label: "Partially Signed",      color: "amber"
    state :executed,         label: "Fully Executed",        color: "green",  terminal: true
    state :expired,          label: "Expired",               color: "orange", terminal: true
    state :cancelled,        label: "Cancelled",             color: "red",    terminal: true

    # Events (transitions)
    event :send_invitation,  from: :draft,                               to: :sent,             label: "Send to Counterparty"
    event :sign_by_owner,    from: [:draft, :sent, :partially_signed],   to: :partially_signed, label: "Owner Signs"
    event :sign_by_counter,  from: [:sent, :partially_signed],           to: :partially_signed, label: "Counterparty Signs"
    event :execute,          from: :partially_signed,                    to: :executed,         label: "Fully Execute"
    event :expire,           from: [:sent, :partially_signed],           to: :expired,          label: "Expire"
    event :cancel,           from: [:draft, :sent, :partially_signed],   to: :cancelled,        label: "Cancel"

    actors :human, :system

    # Guards — business rules that must pass before a transition fires
    guard :has_signing_token, on: :send_invitation,
          description: "Signing token must be present" do |nda|
      nda.signing_token.present?
    end

    guard :has_template_or_custom, on: :send_invitation,
          description: "Must have template or custom document" do |nda|
      nda.nda_template.present? || nda.uses_custom_document?
    end

    guard :both_parties_signed, on: :execute,
          description: "Both owner and counterparty must have signed" do |nda|
      nda.owner_signed_at.present? && nda.counterparty_signed_at.present?
    end

    # Side effects — actions that run after a successful transition
    side_effect :set_sent_timestamps, on: :send_invitation,
                description: "Set sent_at and token expiry" do |nda, _transition|
      nda.update!(sent_at: Time.current, signing_token_expires_at: 7.days.from_now)
    end

    side_effect :send_invitation_email, on: :send_invitation,
                description: "Email signing invitation to counterparty" do |nda, _transition|
      NdaMailer.signing_invitation(nda).deliver_later
    end
  end
  # ── End Lifecycle ────────────────────────────────────────────────────────────

  scope :pending_action, -> { where(status: [:draft, :sent, :partially_signed]) }
  scope :active,         -> { where(status: :executed) }

  before_create :generate_signing_token

  # ── Public API ──────────────────────────────────────────────────────────────

  def send_to_counterparty!(actor: nil)
    transition!(:send_invitation, actor: actor)
  end

  def sign_as_owner!(user, signature)
    self.owner_signed_at       = Time.current
    self.owner_signed_by_user  = user
    self.owner_signature       = signature
    save!
    check_and_execute!(actor: user)
  end

  def sign_as_counterparty!(signature, ip_address)
    self.counterparty_signed_at    = Time.current
    self.counterparty_signature    = signature
    self.counterparty_ip_address   = ip_address
    save!
    FosmTransition.create!(
      object_type: "Nda",   object_id: id,
      from_state:  status,  to_state: (owner_signed_at.present? ? "partially_signed" : status),
      event:       "sign_by_counter",
      actor_type:  "ExternalUser",
      metadata:    { ip: ip_address }
    )
    check_and_execute!
  end

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

  def signing_token_valid?
    signing_token.present? &&
      (signing_token_expires_at.nil? || signing_token_expires_at > Time.current)
  end

  def owner_signed?        = owner_signed_at.present?
  def counterparty_signed? = counterparty_signed_at.present?
  def fully_executed?      = status == "executed"

  private

  def generate_signing_token
    self.signing_token = SecureRandom.urlsafe_base64(32)
  end

  def check_and_execute!(actor: nil)
    if owner_signed_at.present? && counterparty_signed_at.present?
      self.status = :executed
      save!
      FosmTransition.create!(
        object_type: "Nda",      object_id: id,
        from_state:  "partially_signed", to_state: "executed",
        event:       "execute",  actor_type: actor ? "User" : "System",
        actor_id:    actor&.id,  metadata: { auto_executed: true }
      )
    elsif owner_signed_at.present? || counterparty_signed_at.present?
      self.status = :partially_signed unless partially_signed?
      save!
    end
  end

  def template_or_custom_document_required
    if !uses_custom_document? && nda_template_id.blank?
      errors.add(:nda_template, "must be selected when not using a custom document")
    elsif uses_custom_document? && custom_document_text.blank?
      errors.add(:custom_document, "text must be present when using a custom document")
    end
  end
end

# frozen_string_literal: true

class NdasController < ApplicationController
  before_action :authenticate_user!
  before_action :set_nda, only: %i[show edit update destroy send_invitation sign_as_owner cancel]

  def index
    @ndas = Nda.includes(:nda_template, :external_user, :created_by_user)
               .order(created_at: :desc)
    @status_filter = params[:status]
    @ndas = @ndas.where(status: @status_filter) if @status_filter.present?
  end

  def show; end

  def new
    @nda = Nda.new(
      effective_date:               Date.current,
      confidentiality_period_months: 24,
      jurisdiction:                 "State of Delaware, USA"
    )
    @nda_templates = NdaTemplate.active.order(:name)
  end

  def create
    @nda = Nda.new(nda_params)
    @nda.created_by_user = current_user

    if @nda.save
      redirect_to @nda, notice: "NDA created successfully."
    else
      @nda_templates = NdaTemplate.active.order(:name)
      render :new, status: :unprocessable_entity
    end
  end

  def update
    if @nda.draft?
      @nda.update(nda_params) ?
        redirect_to(@nda, notice: "NDA updated.") :
        render(:edit, status: :unprocessable_entity)
    else
      redirect_to @nda, alert: "Cannot edit NDA after it has been sent."
    end
  end

  def destroy
    if @nda.draft?
      @nda.destroy
      redirect_to ndas_path, notice: "NDA deleted."
    else
      redirect_to @nda, alert: "Cannot delete NDA after it has been sent."
    end
  end

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

  def send_invitation
    @nda.send_to_counterparty!(actor: current_user)
    redirect_to @nda, notice: "Invitation sent to #{@nda.external_user.email}."
  rescue Fosm::TransitionService::GuardFailed => e
    redirect_to @nda, alert: "Cannot send: #{e.message}"
  rescue Fosm::TransitionService::InvalidTransition => e
    redirect_to @nda, alert: e.message
  end

  def sign_as_owner
    signature = params[:signature]
    return redirect_to(@nda, alert: "Signature is required.") if signature.blank?

    @nda.sign_as_owner!(current_user, signature)
    msg = @nda.fully_executed? ? "NDA is fully executed." : "You have signed the NDA."
    redirect_to @nda, notice: msg
  end

  def cancel
    @nda.cancel!(actor: current_user)
    redirect_to @nda, notice: "NDA has been cancelled."
  rescue Fosm::TransitionService::InvalidTransition => e
    redirect_to @nda, alert: e.message
  end

  private

  def set_nda
    @nda = Nda.find(params[:id])
  end

  def nda_params
    params.require(:nda).permit(
      :nda_template_id, :effective_date, :confidentiality_period_months,
      :jurisdiction, :notes, :custom_document_text
    )
  end
end

resources :ndas do
  member do
    post :send_invitation
    post :sign_as_owner
    post :cancel
  end
end

# Public signing route (no authentication required)
get '/sign/:token', to: 'nda_signing#show', as: :nda_signing

puts "\n--- Creating Sample NDAs ---"

admin_user = User.find_by!(email: '[email protected]')

# An external counterparty (no system account)
counterparty = ExternalUser.find_or_create_by!(email: '[email protected]') do |u|
  u.name    = "Alice Chen"
  u.company = "Acme Corp"
end

template = NdaTemplate.find_by!(is_default: true)

# Draft NDA
draft_nda = Nda.create!(
  nda_template:               template,
  created_by_user:            admin_user,
  external_user:              counterparty,
  effective_date:             Date.current,
  confidentiality_period_months: 24,
  jurisdiction:               "State of Delaware, USA"
)
puts "Created draft NDA: ##{draft_nda.id}"

# Sent NDA (transition from draft)
sent_nda = Nda.create!(
  nda_template:               template,
  created_by_user:            admin_user,
  external_user:              counterparty,
  effective_date:             Date.current,
  confidentiality_period_months: 12,
  jurisdiction:               "State of California, USA"
)
sent_nda.transition!(:send_invitation, actor: admin_user)
puts "Created sent NDA: ##{sent_nda.id}"

nda = Nda.create!(
  nda_template:               NdaTemplate.default_template,
  created_by_user:            current_user,
  external_user:              counterparty,
  effective_date:             Date.current,
  confidentiality_period_months: 24,
  jurisdiction:               "Singapore"
)
# nda.status => "draft"
# FosmTransition: _new → draft (_create, System)

nda.send_to_counterparty!(actor: current_user)
# Guards pass: signing_token present, template present
# Side effects: sent_at set, signing_token_expires_at = 7.days.from_now
# NdaMailer.signing_invitation(nda).deliver_later queued
# nda.status => "sent"
# FosmTransition: draft → sent (send_invitation, User:current_user)

nda.sign_as_owner!(current_user, "Abhishek Parolkar")
# owner_signed_at set, owner_signature stored
# status → partially_signed
# FosmTransition: sent → partially_signed (sign_by_owner, User:current_user)

nda.sign_as_counterparty!("Alice Chen", "192.168.1.1")
# counterparty_signed_at set, ip stored
# both_parties_signed? → true → check_and_execute! fires
# status → executed
# FosmTransition: partially_signed → executed (execute, System, auto_executed: true)

nda.lifecycle_history.map { |t| "#{t.event}: #{t.from_state} → #{t.to_state} (#{t.actor_type})" }
# => [
#   "_create: _new → draft (System)",
#   "send_invitation: draft → sent (User)",
#   "sign_by_owner: sent → partially_signed (User)",
#   "sign_by_counter: partially_signed → partially_signed (ExternalUser)",
#   "execute: partially_signed → executed (System)"
# ]

# Which NDAs have been stuck in "sent" for more than 7 days?
FosmTransition
  .where(object_type: "Nda", to_state: "sent")
  .where("created_at < ?", 7.days.ago)
  .map(&:object_id)

# How long does the average NDA spend in "sent" before being signed?
FosmTransition.avg_time_in_state("Nda", :sent)
# => 3.2 days (in seconds)

# Which events are most common in the last 30 days?
FosmTransition.transition_counts_by_event("Nda", since: 30.days.ago)
# => { "send_invitation" => 47, "cancel" => 3, "execute" => 31 }

# Current state distribution across all NDAs
FosmTransition.state_distribution("Nda")
# => { "draft" => 12, "sent" => 8, "executed" => 67, "cancelled" => 4 }

has_many :disclosure_documents, class_name: "NdaDisclosureDocument", dependent: :destroy

create_table :nda_disclosure_documents do |t|
  t.references :nda,             null: false, foreign_key: true
  t.string  :title,              null: false
  t.text    :description
  t.string  :share_token,        null: false
  t.datetime :share_expires_at,  null: false
  t.references :uploaded_by_user, null: false, foreign_key: { to_table: :users }
  t.timestamps
end
add_index :nda_disclosure_documents, :share_token, unique: true

RSpec.describe Nda, type: :model do
  let(:admin)       { create(:user, is_admin: true) }
  let(:template)    { create(:nda_template) }
  let(:counterparty){ create(:external_user) }
  let(:nda) do
    create(:nda,
      nda_template:    template,
      created_by_user: admin,
      external_user:   counterparty,
      effective_date:  Date.current
    )
  end

  describe "initial state" do
    it "starts in draft" do
      expect(nda.status).to eq("draft")
    end

    it "records an initial transition on create" do
      expect(nda.lifecycle_history.first.event).to eq("_create")
      expect(nda.lifecycle_history.first.to_state).to eq("draft")
    end
  end

  describe "#transition! :send_invitation" do
    context "when guards pass" do
      it "transitions to sent" do
        expect { nda.transition!(:send_invitation, actor: admin) }
          .to change { nda.reload.status }.from("draft").to("sent")
      end

      it "records a FosmTransition" do
        expect { nda.transition!(:send_invitation, actor: admin) }
          .to change(FosmTransition, :count).by(1)

        t = FosmTransition.last
        expect(t.event).to eq("send_invitation")
        expect(t.from_state).to eq("draft")
        expect(t.to_state).to eq("sent")
        expect(t.actor_type).to eq("User")
        expect(t.actor_id).to eq(admin.id)
      end

      it "sets sent_at via side effect" do
        nda.transition!(:send_invitation, actor: admin)
        expect(nda.reload.sent_at).to be_present
      end

      it "sets signing_token_expires_at to 7 days from now" do
        nda.transition!(:send_invitation, actor: admin)
        expect(nda.reload.signing_token_expires_at).to be_within(1.minute).of(7.days.from_now)
      end
    end

    context "when has_signing_token guard fails" do
      before { nda.update_column(:signing_token, nil) }

      it "raises GuardFailed" do
        expect { nda.transition!(:send_invitation, actor: admin) }
          .to raise_error(Fosm::TransitionService::GuardFailed, /has_signing_token/)
      end

      it "does not change the status" do
        begin
          nda.transition!(:send_invitation, actor: admin)
        rescue Fosm::TransitionService::GuardFailed
        end
        expect(nda.reload.status).to eq("draft")
      end
    end
  end

  describe "#transition! :execute" do
    let(:partially_signed_nda) do
      nda.tap do |n|
        n.transition!(:send_invitation, actor: admin)
        n.update!(owner_signed_at: Time.current, counterparty_signed_at: Time.current)
        n.update_column(:status, "partially_signed")
      end
    end

    context "when both parties have signed" do
      it "transitions to executed" do
        expect { partially_signed_nda.transition!(:execute) }
          .to change { partially_signed_nda.reload.status }.to("executed")
      end
    end

    context "when only owner has signed" do
      before { partially_signed_nda.update!(counterparty_signed_at: nil) }

      it "raises GuardFailed" do
        expect { partially_signed_nda.transition!(:execute) }
          .to raise_error(Fosm::TransitionService::GuardFailed, /both_parties_signed/)
      end
    end
  end

  describe "#transition! from invalid state" do
    it "raises InvalidTransition when cancel fired from executed" do
      nda.update_column(:status, "executed")
      expect { nda.transition!(:cancel, actor: admin) }
        .to raise_error(Fosm::TransitionService::InvalidTransition)
    end
  end

  describe "#available_events" do
    it "returns send_invitation and cancel from draft" do
      expect(nda.available_events.keys).to contain_exactly(:send_invitation, :cancel, :sign_by_owner)
    end

    it "returns nothing from a terminal state" do
      nda.update_column(:status, "executed")
      expect(nda.available_events).to be_empty
    end
  end

  describe "#lifecycle_history" do
    it "returns transitions in chronological order" do
      nda.transition!(:send_invitation, actor: admin)
      events = nda.lifecycle_history.map(&:event)
      expect(events).to eq(["_create", "send_invitation"])
    end
  end
end