Estruturas de Mercado SaaS

class PerfectCompetitionFirm {
  constructor(fixedCost, variableCostCoeff) {
    this.FC = fixedCost;       // $10 (servers, infra)
    this.VC_coeff = variableCostCoeff;  // 5 (custo por q²)
  }

  // Função de custo: C = FC + VC_coeff * q²
  totalCost(q) {
    return this.FC + this.VC_coeff * Math.pow(q, 2);
  }

  // Custo marginal: MC = dC/dq = 2 * VC_coeff * q
  marginalCost(q) {
    return 2 * this.VC_coeff * q;
  }

  // Custo médio: AC = C/q = FC/q + VC_coeff * q
  averageCost(q) {
    return this.FC / q + this.VC_coeff * q;
  }

  // Custo variável médio: AVC = VC/q = VC_coeff * q
  averageVariableCost(q) {
    return this.VC_coeff * q;
  }

  // Maximização de lucro: P = MC → q* = P / (2*VC_coeff)
  optimalQuantity(marketPrice) {
    return marketPrice / (2 * this.VC_coeff);
  }

  // Lucro: π = P*q - C(q)
  profit(marketPrice) {
    const q = this.optimalQuantity(marketPrice);
    const revenue = marketPrice * q;
    const cost = this.totalCost(q);
    return revenue - cost;
  }

  // Shutdown check: continuar operando se P > AVC
  shouldOperate(marketPrice) {
    const q = this.optimalQuantity(marketPrice);
    const avc = this.averageVariableCost(q);
    return marketPrice > avc;
  }
}

// Exemplo: mercado com P = $30
const firm = new PerfectCompetitionFirm(10, 5);
const P = 30;

console.log('=== PERFECT COMPETITION ANALYSIS ===');
console.log(`Market Price: $${P}`);

// Quantidade ótima: P = MC → 30 = 10q → q* = 3
const q_star = firm.optimalQuantity(P);
console.log(`Optimal Quantity: ${q_star} TB/month`);

// Custo total e receita
const revenue = P * q_star;
const cost = firm.totalCost(q_star);
const profit = firm.profit(P);

console.log(`Revenue: $${revenue}`);
console.log(`Total Cost: $${cost}`);
console.log(`Profit: $${profit}`);

// Análise marginal
const mc = firm.marginalCost(q_star);
const ac = firm.averageCost(q_star);
const avc = firm.averageVariableCost(q_star);

console.log('');
console.log('MARGINAL ANALYSIS:');
console.log(`MC at q*: $${mc.toFixed(2)}`);
console.log(`AC at q*: $${ac.toFixed(2)}`);
console.log(`AVC at q*: $${avc.toFixed(2)}`);
console.log(`P - AC = Profit per unit: $${(P - ac).toFixed(2)}`);

// Verificar se deve operar
const shouldOperate = firm.shouldOperate(P);
console.log('');
console.log(`Should operate? ${shouldOperate ? 'YES' : 'NO'}`);
console.log(`Reason: P ($${P}) > AVC ($${avc.toFixed(2)})`);

/*
OUTPUT:
=== PERFECT COMPETITION ANALYSIS ===
Market Price: $30
Optimal Quantity: 3 TB/month
Revenue: $90
Total Cost: $55
Profit: $35

MARGINAL ANALYSIS:
MC at q*: $30.00
AC at q*: $18.33
AVC at q*: $15.00
P - AC = Profit per unit: $11.67

Should operate? YES
Reason: P ($30) > AVC ($15.00)
*/

// Análise com P = $10
const P_low = 10;
const q_new = firm.optimalQuantity(P_low);  // q* = 10/(2*5) = 1

console.log('=== PRICE DROP ANALYSIS ===');
console.log(`New Price: $${P_low}`);
console.log(`New Optimal Quantity: ${q_new} TB/month`);

// Lucro
const revenue_new = P_low * q_new;  // $10
const cost_new = firm.totalCost(q_new);  // 10 + 5*1² = $15
const profit_new = revenue_new - cost_new;  // -$5

console.log(`Revenue: $${revenue_new}`);
console.log(`Total Cost: $${cost_new}`);
console.log(`Profit: $${profit_new}`);  // PREJUÍZO!

// Mas e se fechar?
const profit_if_shutdown = -firm.FC;  // -$10 (só paga FC)

console.log('');
console.log('SHUTDOWN ANALYSIS:');
console.log(`Profit if operate: $${profit_new}`);  // -$5
console.log(`Profit if shutdown: $${profit_if_shutdown}`);  // -$10
console.log(`Decision: ${profit_new > profit_if_shutdown ? 'OPERATE' : 'SHUTDOWN'}`);

// Verificar rule: P vs AVC
const avc_new = firm.averageVariableCost(q_new);  // 5*1 = $5
console.log('');
console.log(`P = $${P_low}, AVC = $${avc_new}`);
console.log(`P > AVC? ${P_low > avc_new ? 'YES → OPERATE' : 'NO → SHUTDOWN'}`);

/*
OUTPUT:
=== PRICE DROP ANALYSIS ===
New Price: $10
New Optimal Quantity: 1 TB/month
Revenue: $10
Total Cost: $15
Profit: -$5

SHUTDOWN ANALYSIS:
Profit if operate: -$5
Profit if shutdown: -$10
Decision: OPERATE

P = $10, AVC = $5
P > AVC? YES → OPERATE

CONCLUSÃO: Mesmo com prejuízo de $5, é melhor operar do que fechar.
Porque fechando você perde $10 (custos fixos).
Operando, você pelo menos cobre custos variáveis ($5) e parte dos fixos ($5).
*/

// Market equilibrium
class MarketEquilibrium {
  constructor(marketSupply, marketDemand) {
    this.supply = marketSupply;
    this.demand = marketDemand;
  }

  // Encontrar P* e Q* onde Qs(P) = Qd(P)
  findEquilibrium() {
    // Supply: Q = 0.6P (do exemplo acima)
    // Demand: Q = 48 - P (hipotético)

    // Igualar: 0.6P = 48 - P
    // 1.6P = 48
    // P* = 30

    const P_star = 30;
    const Q_star = 0.6 * P_star;  // 18

    return { P: P_star, Q: Q_star };
  }

  // Implicações para cada firma
  firmImplications(equilibrium, numberOfFirms) {
    const { P, Q } = equilibrium;
    const q_firm = Q / numberOfFirms;

    return {
      price: P,
      quantity: q_firm,
      revenue: P * q_firm,
      // Cada firma produz onde P = MC
      marginalCost: P,  // Por construção!
    };
  }
}

// Demand curve hipotética: Q = 48 - P
const marketDemand = {
  quantityDemanded: (P) => 48 - P,
};

const equilibrium = new MarketEquilibrium(marketSupply, marketDemand);
const eq = equilibrium.findEquilibrium();

console.log('=== MARKET EQUILIBRIUM ===');
console.log(`Equilibrium Price: $${eq.P}`);
console.log(`Equilibrium Quantity: ${eq.Q} TB/month`);
console.log('');

const firmEq = equilibrium.firmImplications(eq, 6);
console.log('=== FIRM-LEVEL IMPLICATIONS ===');
console.log(`Each firm produces: ${firmEq.quantity} TB/month`);
console.log(`Each firm charges: $${firmEq.price}`);
console.log(`Each firm's revenue: $${firmEq.revenue}`);
console.log(`Each firm's MC at q*: $${firmEq.marginalCost}`);

// Verificar: P = MC?
const firm_analysis = new PerfectCompetitionFirm(10, 5);
const mc_check = firm_analysis.marginalCost(firmEq.quantity);
console.log('');
console.log('VERIFICATION:');
console.log(`P = MC? $${firmEq.price} = $${mc_check} → ${firmEq.price === mc_check ? 'YES ✓' : 'NO'}`);

/*
OUTPUT:
=== MARKET EQUILIBRIUM ===
Equilibrium Price: $30
Equilibrium Quantity: 18 TB/month

=== FIRM-LEVEL IMPLICATIONS ===
Each firm produces: 3 TB/month
Each firm charges: $30
Each firm's revenue: $90
Each firm's MC at q*: $30

VERIFICATION:
P = MC? $30 = $30 → YES ✓

MAGIA DO MERCADO:
Cada firma, maximizando seu próprio lucro (P=MC), produz exatamente
a quantidade que o mercado demanda. Não há coordenação central.
É a "mão invisível" de Adam Smith em ação.
*/

// Consumer Surplus em SaaS
class ConsumerSurplus {
  constructor(willingnessToPay, marketPrice) {
    this.WTP = willingnessToPay;  // Willingness To Pay
    this.P = marketPrice;
  }

  // Surplus individual
  individualSurplus() {
    if (this.WTP < this.P) return 0;  // Não compra
    return this.WTP - this.P;
  }

  // Decisão de compra
  willBuy() {
    return this.WTP >= this.P;
  }
}

// Exemplo: diferentes usuários de analytics SaaS
const users = [
  { name: 'Enterprise Corp', wtp: 500 },  // High value user
  { name: 'Startup A', wtp: 300 },
  { name: 'Startup B', wtp: 200 },
  { name: 'Freelancer', wtp: 100 },
  { name: 'Hobbyist', wtp: 50 },
];

const marketPrice = 150;  // Preço de mercado

console.log('=== CONSUMER SURPLUS ANALYSIS ===');
console.log(`Market Price: $${marketPrice}/month\n`);

let totalSurplus = 0;
let buyersCount = 0;

users.forEach(user => {
  const cs = new ConsumerSurplus(user.wtp, marketPrice);
  const surplus = cs.individualSurplus();

  if (cs.willBuy()) {
    console.log(`${user.name}:`);
    console.log(`  WTP: $${user.wtp}`);
    console.log(`  Surplus: $${surplus}`);
    console.log(`  Buy: YES\n`);

    totalSurplus += surplus;
    buyersCount++;
  } else {
    console.log(`${user.name}: WTP too low ($${user.wtp}) → NO PURCHASE\n`);
  }
});

console.log('=== MARKET SUMMARY ===');
console.log(`Total Buyers: ${buyersCount}`);
console.log(`Total Consumer Surplus: $${totalSurplus}`);
console.log(`Average Surplus per Buyer: $${(totalSurplus / buyersCount).toFixed(2)}`);

/*
OUTPUT:
=== CONSUMER SURPLUS ANALYSIS ===
Market Price: $150/month

Enterprise Corp:
  WTP: $500
  Surplus: $350
  Buy: YES

Startup A:
  WTP: $300
  Surplus: $150
  Buy: YES

Startup B:
  WTP: $200
  Surplus: $50
  Buy: YES

Freelancer: WTP too low ($100) → NO PURCHASE
Hobbyist: WTP too low ($50) → NO PURCHASE

=== MARKET SUMMARY ===
Total Buyers: 3
Total Consumer Surplus: $550
Average Surplus per Buyer: $183.33

INSIGHT: O mercado está "saudável" - compradores recebem valor
significativo (surplus médio de $183). Isso aumenta satisfação e retention.
*/

// Producer Surplus com firmas de diferentes eficiências
class SaaSFirm {
  constructor(name, marginalCost, capacity) {
    this.name = name;
    this.MC = marginalCost;  // Custo marginal por cliente
    this.capacity = capacity;
  }

  producerSurplus(marketPrice, quantitySold) {
    if (marketPrice <= this.MC) return 0;
    return (marketPrice - this.MC) * quantitySold;
  }
}

// Mercado de CRM: firmas com diferentes eficiências
const firms = [
  new SaaSFirm('Salesforce', 10, 1000),    // Alta eficiência
  new SaaSFirm('HubSpot', 20, 800),
  new SaaSFirm('Zoho', 30, 500),
  new SaaSFirm('Newcomer', 50, 200),        // Baixa eficiência
];

const marketPrice = 50;  // Preço de equilíbrio

console.log('=== PRODUCER SURPLUS ANALYSIS ===');
console.log(`Market Price: $${marketPrice}/client\n`);

let totalProducerSurplus = 0;

firms.forEach(firm => {
  // Firma produz até sua capacidade se P > MC
  const quantity = marketPrice > firm.MC ? firm.capacity : 0;
  const ps = firm.producerSurplus(marketPrice, quantity);

  console.log(`${firm.name}:`);
  console.log(`  MC: $${firm.MC}`);
  console.log(`  Quantity: ${quantity} clients`);
  console.log(`  Producer Surplus: $${ps.toLocaleString()}`);
  console.log(`  Profit per client: $${marketPrice - firm.MC}\n`);

  totalProducerSurplus += ps;
});

console.log('=== MARKET SUMMARY ===');
console.log(`Total Producer Surplus: $${totalProducerSurplus.toLocaleString()}`);

/*
OUTPUT:
=== PRODUCER SURPLUS ANALYSIS ===
Market Price: $50/client

Salesforce:
  MC: $10
  Quantity: 1000 clients
  Producer Surplus: $40,000
  Profit per client: $40

HubSpot:
  MC: $20
  Quantity: 800 clients
  Producer Surplus: $24,000
  Profit per client: $30

Zoho:
  MC: $30
  Quantity: 500 clients
  Producer Surplus: $10,000
  Profit per client: $20

Newcomer:
  MC: $50
  Quantity: 200 clients
  Producer Surplus: $0
  Profit per client: $0

=== MARKET SUMMARY ===
Total Producer Surplus: $74,000

INSIGHT: A firma marginal (Newcomer) tem lucro zero, mas as
mais eficientes (Salesforce, HubSpot, Zoho) capturam surplus
devido à sua vantagem de custo.
*/

// Deadweight Loss com Price Cap
class Market {
  constructor(demandCurve, supplyCurve) {
    this.demand = demandCurve;  // Q = a - bP
    this.supply = supplyCurve;  // Q = c + dP
  }

  // Equilíbrio competitivo
  equilibrium() {
    // Demand: Q = 200 - 2P
    // Supply: Q = -50 + P
    // Igualar: 200 - 2P = -50 + P
    // 250 = 3P → P* = 83.33, Q* = 33.33

    const P_star = 250 / 3;
    const Q_star = 200 - 2 * P_star;

    return { price: P_star, quantity: Q_star };
  }

  // Com price cap
  priceCapOutcome(cap) {
    // Ao preço cap, quantas unidades são ofertadas?
    const Q_supplied = -50 + cap;  // Supply curve
    const Q_demanded = 200 - 2 * cap;  // Demand curve

    // Quantidade real = mínimo (supply constraints)
    const Q_actual = Math.min(Q_supplied, Q_demanded);

    return {
      price: cap,
      quantity: Q_actual,
      excessDemand: Q_demanded - Q_supplied
    };
  }

  // Consumer Surplus
  consumerSurplus(P, Q) {
    // CS = 0.5 * base * altura
    // base = Q, altura = (P_intercept - P)
    const P_intercept = 100;  // Quando Q=0, P=100
    return 0.5 * Q * (P_intercept - P);
  }

  // Producer Surplus
  producerSurplus(P, Q) {
    // PS = 0.5 * base * altura
    // base = Q, altura = (P - MC_intercept)
    const MC_intercept = 50;  // Quando Q=0, MC=50
    return 0.5 * Q * (P - MC_intercept);
  }

  // Welfare
  welfare(P, Q) {
    return this.consumerSurplus(P, Q) + this.producerSurplus(P, Q);
  }
}

const market = new Market();

// Caso 1: Equilíbrio competitivo
const eq = market.equilibrium();
console.log('=== COMPETITIVE EQUILIBRIUM ===');
console.log(`Price: $${eq.price.toFixed(2)}`);
console.log(`Quantity: ${eq.quantity.toFixed(2)} units`);

const CS_eq = market.consumerSurplus(eq.price, eq.quantity);
const PS_eq = market.producerSurplus(eq.price, eq.quantity);
const W_eq = market.welfare(eq.price, eq.quantity);

console.log(`Consumer Surplus: $${CS_eq.toFixed(2)}`);
console.log(`Producer Surplus: $${PS_eq.toFixed(2)}`);
console.log(`Total Welfare: $${W_eq.toFixed(2)}\n`);

// Caso 2: Price cap de $60
const cap = 60;
const capOutcome = market.priceCapOutcome(cap);
console.log('=== WITH PRICE CAP ($60) ===');
console.log(`Price: $${capOutcome.price}`);
console.log(`Quantity: ${capOutcome.quantity} units`);
console.log(`Excess Demand: ${capOutcome.excessDemand} units (shortage!)\n`);

const CS_cap = market.consumerSurplus(cap, capOutcome.quantity);
const PS_cap = market.producerSurplus(cap, capOutcome.quantity);
const W_cap = market.welfare(cap, capOutcome.quantity);

console.log(`Consumer Surplus: $${CS_cap.toFixed(2)}`);
console.log(`Producer Surplus: $${PS_cap.toFixed(2)}`);
console.log(`Total Welfare: $${W_cap.toFixed(2)}\n`);

// Deadweight Loss
const DWL = W_eq - W_cap;
console.log('=== WELFARE ANALYSIS ===');
console.log(`Change in CS: $${(CS_cap - CS_eq).toFixed(2)}`);
console.log(`Change in PS: $${(PS_cap - PS_eq).toFixed(2)}`);
console.log(`Deadweight Loss: $${DWL.toFixed(2)}\n`);

console.log('TRANSFER vs LOSS:');
console.log(`- Some PS transferred to CS (rectangle)`);
console.log(`- But $${DWL.toFixed(2)} literally disappeared (triangle)`);
console.log(`- Lost from transactions that would benefit both sides\n`);

/*
OUTPUT:
=== COMPETITIVE EQUILIBRIUM ===
Price: $83.33
Quantity: 33.33 units
Consumer Surplus: $277.78
Producer Surplus: $555.56
Total Welfare: $833.33

=== WITH PRICE CAP ($60) ===
Price: $60
Quantity: 10 units
Excess Demand: 70 units (shortage!)

Consumer Surplus: $200.00
Producer Surplus: $50.00
Total Welfare: $250.00

=== WELFARE ANALYSIS ===
Change in CS: $-77.78
Change in PS: $-505.56
Deadweight Loss: $583.33

TRANSFER vs LOSS:
- Some PS transferred to CS (rectangle)
- But $583.33 literally disappeared (triangle)
- Lost from transactions that would benefit both sides

CONCLUSÃO: O price cap DESTRUIU $583 de welfare.
Consumidores perderam $78, produtores perderam $506.
A sociedade como um todo está $583 PIOR.
*/