// content.jsx — bilingual copy + shared building blocks for all three directions.
// Centralised so we only translate once and so palette/font swaps via Tweaks
// can target a single source.

const COPY = {
  it: {
    nav: ['Lavoro', 'Filosofia', 'Servizi', 'FAQ', 'Contatti'],
    role: 'Fractional CTO',
    location: 'Remote · ovunque',
    heroEyebrow: 'Fractional CTO',
    heroHello: 'Ciao, sono',
    heroHelloName: 'Bartolomeo Tiralongo',
    heroLine1: 'Costruisco i prodotti tech',
    heroLine2: 'da zero a fatturato.',
    heroLine3: 'di un CTO',
    heroLine4: 'senza il costo',
    heroLine5: 'di assumerne uno.',
    heroSub: 'Strategia di prodotto, architettura che regge, primi hire. La guida tecnica di un CTO senza il costo di assumerne uno.',
    heroSubShort: 'Strategia di prodotto, architettura che regge, primi hire.',
    cta: 'Scrivimi cosa stai costruendo',
    ctaSub: 'ti rispondo il più presto possibile',
    numbers: [
      { v: '150k', l: 'download app', sub: 'rating 4.5★ · BRUM Patenti' },
      { v: '50k', l: 'utenti attivi/mese', sub: 'BRUM, oggi' },
      { v: '2', l: 'mesi concept → MVP', sub: 'in store' },
      { v: '~10', l: 'anni in tech', sub: 'Ferrari → oggi' },
    ],

    philosophyKicker: '01 — Filosofia',
    philosophyTitle: 'Vengo da un mondo dove se il sistema sbaglia, si ferma qualcosa di vero. Non da slide.',
    philosophyP1: 'Ho iniziato in Ferrari sui controlli powertrain, ISO 26262, sicurezza funzionale. Poi RINA, Industria 4.0. Poi prodotto, scale-up, team da zero. Adesso costruisco prodotti dove il bug non spegne un motore ma fa perdere un cliente — e per me è la stessa cosa.',
    philosophyP2: 'Non vendo ore di codice. Vendo decisioni che non pagherai per cinque anni: lo stack giusto, l\'architettura che regge la prossima ondata, l\'assunzione che non rimpiangi, il "no" detto al momento giusto.',

    processKicker: '02 — Come funziona',
    processIntro: 'Part-time. A milestones. Sempre dentro il team.',
    phasesTitle: 'Dal capire al',
    phasesTitleAccent: 'consegnare',
    phasesSub: 'Niente template. Adatto la cadenza al punto in cui sei: che serva un parere a freddo, una guida operativa o un partner per scalare.',
    phases: [
      {
        when: 'Week 1', t: 'Capire',
        d: 'Due call, niente slide. Leggo prodotto, team e vincoli reali. Ti restituisco una mappa onesta dei rischi tecnici.',
        bullets: [
          'Diagnosi tecnica e organizzativa',
          'Punti caldi e fast win',
          'Report scritto, non slide',
        ],
      },
      {
        when: 'Week 2–3', t: 'Decidere',
        d: 'Mettiamo per iscritto stack, roadmap e i sì/no dei prossimi 90 giorni. Ogni decisione ha un perché e un costo dichiarato.',
        bullets: [
          'Roadmap a 90 giorni',
          'Stack scelto con un motivo',
          'Decisioni con costo dichiarato',
        ],
      },
      {
        when: 'Month 1–3', t: 'Costruire',
        d: 'Sono dentro il team 1.5 giorni a settimana. Sblocco, faccio code review, parlo con i fornitori, assumo chi serve.',
        bullets: [
          'Architettura messa a terra',
          'Ritmo di delivery costante',
          'Hire critici fatti bene',
        ],
      },
      {
        when: 'Month 3+', t: 'Lasciare',
        d: 'Quando il team cammina da solo, esco. Resta una fondazione che non si rompe al prossimo bivio.',
        bullets: [
          'Team autonomo',
          'Documentazione viva',
          'Continuità senza dipendenza',
        ],
      },
    ],
    howKicker: 'Come funziona un Fractional CTO',
    howIntro: 'Una giornata e mezza a settimana, dentro il team, con obiettivi misurabili ogni 30 giorni.',
    howBullets: [
      { k: '1.5 g / settimana', d: 'Lunedì allineamento, mercoledì esecuzione. Sono nei vostri canali Slack/Linear ogni giorno, non solo nelle ore fatturate.' },
      { k: 'Milestone 30 / 60 / 90', d: 'Ogni 30 giorni una milestone scritta: cosa esce, cosa si misura, cosa cambia. Niente fatturazione a vuoto.' },
      { k: 'Contratto a 3 mesi', d: 'Rinnovo mensile dopo il primo trimestre. Se non servo più, esco — è il successo, non il fallimento.' },
      { k: 'Costo dichiarato', d: 'Tariffa fissa mensile. Niente sorprese, niente ore di codice da rendicontare.' },
    ],
    steps: [
      { n: '01', t: 'Ascolto', d: 'Due call. Capisco il prodotto, il team, i numeri, le bugie che ti racconti. Restituisco una mappa onesta del rischio tecnico.' },
      { n: '02', t: 'Decido con te', d: 'Roadmap a 90 giorni, stack, primi hire, integrazioni critiche. Documenti scritti, non slide. Ogni decisione ha un perché e un costo dichiarato.' },
      { n: '03', t: 'Eseguo accanto', d: 'Una giornata e mezza a settimana dentro il team. Sblocco, faccio code review, parlo con i fornitori, assumo chi serve. Quando non servo più, esco.' },
    ],

    servicesKicker: '03 — Servizi',
    servicesIntro: 'Tre pilastri. Cinque modi di lavorare insieme.',
    servicePillars: [
      {
        label: 'Decisioni',
        gloss: 'Cosa fare, in che ordine, perché — e cosa non fare.',
        services: [
          { t: 'Fractional CTO', p: 'da definire', d: 'Guida tecnica continuativa per startup pre-seed e seed. 1.5 giorni a settimana, dentro il team, milestone scritte ogni 30 giorni.' },
          { t: 'Tech Advisory', p: 'da definire', d: 'Sparring partner per founder. Call quindicinali, review architetturale, presenza nei momenti che contano.' },
        ],
      },
      {
        label: 'Architettura',
        gloss: 'Sistemi che reggono la prossima ondata. E quelli vecchi che vanno raddrizzati.',
        services: [
          { t: 'Technical Audit', p: 'da definire', d: 'Due settimane dentro al codice e al team. Output: report scritto, roadmap di risanamento, ranking dei rischi tecnici.' },
          { t: 'Automazione & AI nei processi', p: 'da definire', d: 'Workflow operativi tagliati e ricuciti con LLM, integrazioni, pipeline. Il lavoro noioso fatto fare alle macchine — in modo affidabile.' },
        ],
      },
      {
        label: 'Esecuzione',
        gloss: 'Dal piano al ship. Le persone giuste, al ritmo giusto.',
        services: [
          { t: 'Product Management', p: 'da definire', d: 'Roadmap di prodotto, prioritizzazione, discovery con utenti, definizione di cosa esce e cosa no. Il prodotto in mano a chi lo costruisce.' },
          { t: 'Project Management', p: 'da definire', d: 'Delivery sotto controllo: milestone, ritmo settimanale, gestione rischi e dipendenze. Il piano che resta vivo, non quello che ammuffisce in Notion.' },
        ],
      },
    ],
    services: [
      { t: 'Fractional CTO', p: 'da definire', d: 'Guida tecnica continuativa per startup pre-seed e seed. 1–2 giorni a settimana, dentro il team.' },
      { t: 'Tech Advisory', p: 'da definire', d: 'Sparring partner per founder. Call quindicinali, review architetturale, presenza nei momenti che contano.' },
      { t: 'Technical Audit', p: 'da definire', d: 'Due settimane dentro al codice e al team. Output: report scritto, roadmap di risanamento, ranking dei rischi.' },
      { t: 'Hiring Tech', p: 'da definire', d: 'Disegno del primo team tech. Job description, screening, interview loop, offerta. Ti tengo lontano dagli errori da € 100k.' },
    ],

    pathKicker: 'Dove ho costruito',
    pathLogos: [
      { name: 'GaiaGo', sub: '’19 — ’21' },
      { name: 'Fiscozen', sub: '’21 — ’22' },
      { name: 'GoVolt', sub: '’22 — ’24' },
      { name: 'BRUM', sub: '’25 — oggi' },
      { name: 'Plug and Play', sub: 'mentor' },
    ],
    contactDrawerTitle: 'Da dove vuoi partire?',
    contactDrawerBody: 'Scegli un canale, ti rispondo entro 48 ore.',
    contactMailLabel: 'Scrivimi una mail',
    contactMailSub: 'bart@bartofactory.com · risposta in 48h',
    contactCalLabel: 'Prenota una call',
    contactCalSub: '30 min · niente pitch · Calendly',
    contactClose: 'chiudi',

    workKicker: '04 — Lavoro',
    workIntro: 'Cose costruite, non slide presentate. Specialità: zero → fatturato.',
    cases: [
      {
        client: 'Tana della Tartaruga', role: 'Fractional CTO · 2024 — oggi',
        title: 'CRM custom · bot Telegram · email marketing automatizzato.',
        body: 'Disegno e build di un CRM su misura, integrato con bot Telegram e pipeline email automatizzata. Da Excel a dati strutturati, segmentazione automatica dei clienti.',
        stat1: '1', stat1l: 'CRM custom',
        stat2: 'Telegram', stat2l: 'bot integrato',
        stat3: 'auto', stat3l: 'email segmentate',
      },
      {
        client: 'BRUM Patenti', role: 'CTO · 2025 — oggi',
        title: 'Dal concept al primo MVP in store in 2 mesi. Oggi 150k download a 4.5★, 50k attivi/mese.',
        body: 'Roadmap di prodotto, app live in 2 mesi, iterazione continua ascoltando utenti reali. Piattaforma web+mobile (quiz, teoria, upload documenti, pagamenti, referral), integrazione col Portale dell\'Automobilista.',
        stat1: '150k', stat1l: 'download',
        stat2: '4.5★', stat2l: 'rating store',
        stat3: '2 mesi', stat3l: 'concept → MVP',
      },
      {
        client: 'eWibe', role: 'Fractional CTO · 2024 — oggi',
        title: 'Refactoring strutturale e stabilizzazione di una piattaforma già live.',
        body: 'Allineamento tra aspettative di prodotto, founder e debito tecnico. Performance, manutenibilità, stabilità. La parte difficile: dire di no quando serve.',
        stat1: '⤴', stat1l: 'stabilità',
        stat2: '−40%', stat2l: 'tempo deploy',
        stat3: '✓', stat3l: 'roadmap allineata',
      },
      {
        client: 'GoVolt Mobility', role: 'Eng Manager · 2022 — 2024',
        title: 'Team di ingegneria remoto costruito da zero (6+), infrastruttura cloud GCP, microservizi scalabili per la logistica. Da strategia a esecuzione.',
        body: 'Architettura a microservizi per pianificazione, swap batterie, manutenzione e analytics. 6+ ingegneri assunti e gestiti in remoto. Pipeline ETL e dashboard operative.',
        stat1: '6+', stat1l: 'ingegneri assunti',
        stat2: 'GCP', stat2l: 'microservizi',
        stat3: '0→1', stat3l: 'team da zero',
      },
    ],

    testimonialsKicker: '05 — Cosa dicono',
    testimonials: [
      {
        quote: '[Frase concreta sul risultato sbloccato — da raccogliere dal founder eWibe]',
        author: 'Founder', role: 'CEO', company: 'eWibe',
        placeholder: true,
      },
      {
        quote: '[Frase concreta su team building e infrastruttura — da raccogliere dal CEO GoVolt]',
        author: 'CEO', role: 'Founder', company: 'GoVolt Mobility',
        placeholder: true,
      },
      {
        quote: '[Frase concreta sul CRM e impatto operativo — da raccogliere da Federico]',
        author: 'Federico Ronzoni', role: 'Founder', company: 'Tana della Tartaruga',
        placeholder: true,
      },
    ],

    faqKicker: '07 — FAQ',
    faqIntro: 'Le domande che mi fanno tutti.',
    faqs: [
      {
        q: 'Come funziona concretamente?',
        a: 'Una giornata e mezza a settimana dentro il team, con milestone scritte ogni 30 giorni. Contratto iniziale di 3 mesi, rinnovo mensile dopo il primo trimestre. Tariffa fissa mensile, niente ore di codice da rendicontare. Sono nei vostri canali Slack/Linear ogni giorno, non solo nelle ore fatturate.',
      },
      {
        q: 'Cosa vuol dire Fractional CTO?',
        a: 'Un CTO part-time, dentro il team con un mandato chiaro a milestone. Paghi per decisioni e direzione — architettura, hire, roadmap — non per ore di codice.',
      },
      {
        q: 'Con quante startup lavori in parallelo?',
        a: 'Poche, per scelta. La qualità del mio lavoro dipende dal non spalmarmi. Preferisco dire di no che fare il consulente a metà.',
      },
      {
        q: 'Scrivi anche codice?',
        a: 'Sì, quando serve sbloccare o per fare scelte architetturali con le mani sporche. Non è il mestiere quotidiano: il valore sta a monte (decisioni, hire, architettura).',
      },
      {
        q: 'Ti interfacci anche con investitori e due diligence?',
        a: 'Sì. Tech DD, call con VC, pitch tecnici. Una parte importante del lavoro è raccontare bene la tech a chi non la fa.',
      },
      {
        q: 'Quanto dura un ingaggio tipico?',
        a: 'Contratto iniziale di 3 mesi, poi rinnovo mensile. Engagement medio: 4–8 mesi. Quando non servo più, esco — è il successo, non il fallimento.',
      },
    ],
    footerAvailability: 'Lavoro con poche startup alla volta. Se c\'è spazio te lo dico subito.',

    timelineKicker: 'Da dove vengo',
    timeline: [
      { y: '2013', t: 'Ferrari', d: 'Controllo powertrain · ISO 26262' },
      { y: '2017', t: 'RINA', d: 'Architettura innovazione · Industria 4.0' },
      { y: '2019', t: 'GaiaGo', d: 'Tech Lead · team 10' },
      { y: '2021', t: 'Fiscozen', d: 'Product Manager · fintech regolata' },
      { y: '2022', t: 'GoVolt', d: 'Acting CTO · team da zero' },
      { y: '2024', t: 'bartofactory', d: 'Fractional CTO · independent' },
      { y: '2025', t: 'BRUM', d: 'CTO · 200k utenti' },
    ],

    stackKicker: '05 — Stack',
    stackIntro: 'Pragmatico. Scelgo cose noiose che funzionano. Niente hype.',
    stackGroups: [
      { g: 'Backend', items: ['Node', 'Python', 'Go', 'Postgres', 'Redis'] },
      { g: 'Frontend', items: ['React', 'Next.js', 'React Native', 'TypeScript'] },
      { g: 'Cloud', items: ['GCP', 'AWS', 'Cloudflare', 'Vercel'] },
      { g: 'Data', items: ['BigQuery', 'dbt', 'Airflow', 'Metabase'] },
      { g: 'Pratica', items: ['Linear', 'Notion', 'GitHub', 'Sentry'] },
    ],

    ctaKicker: '08 — Sentiamoci',
    ctaTitle: 'Scrivimi cosa stai costruendo.',
    ctaBody: 'Una mail, una nota vocale, un link al prodotto. In 48 ore ti rispondo onestamente: è una cosa in cui posso essere utile, oppure no.',
    ctaButton: 'Scrivimi una mail',
    ctaAlt: 'oppure prenota una call su',

    footerLine: 'bartofactory · P.IVA IT12345670123 · ',
    madeIn: 'fatto a mano · Italia',
  },
  en: {
    nav: ['Work', 'Philosophy', 'Services', 'FAQ', 'Contact'],
    role: 'Fractional CTO',
    location: 'Remote · anywhere',
    heroEyebrow: 'Fractional CTO',
    heroHello: 'Hi, I’m',
    heroHelloName: 'Bartolomeo Tiralongo',
    heroLine1: 'I build tech products',
    heroLine2: 'from zero to revenue.',
    heroLine3: 'of a CTO',
    heroLine4: 'without the cost',
    heroLine5: 'of hiring one.',
    heroSub: 'Product strategy, architecture that holds, first hires. The technical lead of a CTO without the cost of hiring one.',
    heroSubShort: 'Product strategy, architecture that holds, first hires.',
    cta: 'Tell me what you\'re building',
    ctaSub: 'I’ll get back to you as soon as possible',
    numbers: [
      { v: '150k', l: 'app downloads', sub: 'rating 4.5★ · BRUM Patenti' },
      { v: '50k', l: 'active users/month', sub: 'BRUM, today' },
      { v: '2', l: 'months concept → MVP', sub: 'in store' },
      { v: '~10', l: 'years in tech', sub: 'Ferrari → today' },
    ],

    philosophyKicker: '01 — Philosophy',
    philosophyTitle: 'I come from a world where if the system fails, something real stops. Not from slides.',
    philosophyP1: 'I started at Ferrari, on powertrain controls, ISO 26262, functional safety. Then RINA, Industry 4.0. Then product, scale-ups, teams from scratch. Now I build products where the bug doesn\'t kill an engine but loses a customer — and to me, it\'s the same thing.',
    philosophyP2: 'I don\'t sell hours of code. I sell decisions you won\'t pay for in five years: the right stack, an architecture that survives the next wave, a hire you won\'t regret, the "no" said at the right moment.',

    processKicker: '02 — How it works',
    processIntro: 'Part-time. Milestone-driven. Always inside the team.',
    phasesTitle: 'From understanding to',
    phasesTitleAccent: 'shipping',
    phasesSub: 'No templates. The pace adapts to where you are — whether you need a cold-eye reading, a hands-on lead, or a partner to scale.',
    phases: [
      {
        when: 'Week 1', t: 'Understand',
        d: 'Two calls, no slides. I read the product, the team, the real constraints. You get back an honest map of technical risk.',
        bullets: [
          'Technical & organizational diagnosis',
          'Hot spots and fast wins',
          'Written report, not slides',
        ],
      },
      {
        when: 'Week 2–3', t: 'Decide',
        d: 'We commit to stack, roadmap and the 90-day yes/no in writing. Every decision has a reason and a stated cost.',
        bullets: [
          '90-day roadmap',
          'Stack chosen with a reason',
          'Decisions with a stated cost',
        ],
      },
      {
        when: 'Month 1–3', t: 'Build',
        d: 'Inside the team, 1.5 days a week. I unblock, review code, talk to vendors, hire who\'s needed.',
        bullets: [
          'Architecture put down',
          'Steady delivery cadence',
          'Critical hires done well',
        ],
      },
      {
        when: 'Month 3+', t: 'Leave',
        d: 'When the team walks on its own, I leave. What stays is a foundation that doesn\'t crack at the next fork.',
        bullets: [
          'Autonomous team',
          'Living documentation',
          'Continuity without dependency',
        ],
      },
    ],
    howKicker: 'How a Fractional CTO actually works',
    howIntro: 'A day and a half a week, inside the team, with measurable milestones every 30 days.',
    howBullets: [
      { k: '1.5 days / week', d: 'Monday alignment, Wednesday execution. I\'m in your Slack/Linear every day, not just billable hours.' },
      { k: 'Milestones 30 / 60 / 90', d: 'Every 30 days a written milestone: what ships, what we measure, what changes. No empty invoices.' },
      { k: '3-month contract', d: 'Monthly renewal after the first quarter. If I\'m no longer needed, I leave — that\'s the success, not the failure.' },
      { k: 'Flat fee', d: 'Fixed monthly rate. No surprises, no hours to account for.' },
    ],
    steps: [
      { n: '01', t: 'Listen', d: 'Two calls. I understand the product, the team, the numbers, the lies you tell yourself. I give you back an honest map of technical risk.' },
      { n: '02', t: 'Decide with you', d: '90-day roadmap, stack, first hires, critical integrations. Written documents, not slides. Every decision has a why and a stated cost.' },
      { n: '03', t: 'Execute alongside', d: 'A day and a half a week inside the team. I unblock, review code, talk to vendors, hire who\'s needed. When I\'m no longer needed, I leave.' },
    ],

    servicesKicker: '03 — Services',
    servicesIntro: 'Three pillars. Five ways to work together.',
    servicePillars: [
      {
        label: 'Decisions',
        gloss: 'What to do, in what order, why — and what not to do.',
        services: [
          { t: 'Fractional CTO', p: 'to define', d: 'Continuous technical lead for pre-seed and seed startups. 1.5 days a week, inside the team, written milestones every 30 days.' },
          { t: 'Tech Advisory', p: 'to define', d: 'Sparring partner for founders. Bi-weekly calls, architecture review, presence in moments that matter.' },
        ],
      },
      {
        label: 'Architecture',
        gloss: 'Systems that survive the next wave. And old ones that need straightening.',
        services: [
          { t: 'Technical Audit', p: 'to define', d: 'Two weeks inside the code and the team. Output: written report, remediation roadmap, ranked risks.' },
          { t: 'Automation & AI in operations', p: 'to define', d: 'Operational workflows cut and re-stitched with LLMs, integrations, pipelines. The boring work done by machines — reliably.' },
        ],
      },
      {
        label: 'Execution',
        gloss: 'From the plan to the ship. The right people, at the right pace.',
        services: [
          { t: 'Product Management', p: 'to define', d: 'Product roadmap, prioritization, user discovery, deciding what ships and what doesn\'t. Product in the hands of the people who build it.' },
          { t: 'Project Management', p: 'to define', d: 'Delivery under control: milestones, weekly cadence, risk and dependency management. The plan that stays alive — not the one that rots in Notion.' },
        ],
      },
    ],
    services: [
      { t: 'Fractional CTO', p: 'to define', d: 'Continuous technical lead for pre-seed and seed startups. 1–2 days a week, inside the team.' },
      { t: 'Tech Advisory', p: 'to define', d: 'Sparring partner for founders. Bi-weekly calls, architecture review, presence in moments that matter.' },
      { t: 'Technical Audit', p: 'to define', d: 'Two weeks inside the code and the team. Output: written report, remediation roadmap, ranked risks.' },
      { t: 'Tech Hiring', p: 'to define', d: 'Design of your first tech team. Job description, screening, interview loop, offer. I keep you away from €100k mistakes.' },
    ],

    pathKicker: 'Where I built',
    pathLogos: [
      { name: 'GaiaGo', sub: '’19 — ’21' },
      { name: 'Fiscozen', sub: '’21 — ’22' },
      { name: 'GoVolt', sub: '’22 — ’24' },
      { name: 'BRUM', sub: '’25 — today' },
      { name: 'Plug and Play', sub: 'mentor' },
    ],
    contactDrawerTitle: 'Where do we start?',
    contactDrawerBody: 'Pick a channel, I reply within 48 hours.',
    contactMailLabel: 'Send me an email',
    contactMailSub: 'bart@bartofactory.com · reply in 48h',
    contactCalLabel: 'Book a call',
    contactCalSub: '30 min · no pitch · Calendly',
    contactClose: 'close',

    workKicker: '04 — Work',
    workIntro: 'Things built, not slides presented. Specialty: zero → revenue.',
    cases: [
      {
        client: 'Tana della Tartaruga', role: 'Fractional CTO · 2024 — present',
        title: 'Custom CRM · Telegram bot · automated email marketing.',
        body: 'Design and build of a custom CRM, integrated with a Telegram bot and an automated email pipeline. From Excel to structured data with automatic customer segmentation.',
        stat1: '1', stat1l: 'custom CRM',
        stat2: 'Telegram', stat2l: 'bot integrated',
        stat3: 'auto', stat3l: 'segmented emails',
      },
      {
        client: 'BRUM Patenti', role: 'CTO · 2025 — present',
        title: 'From concept to first MVP in store in 2 months. Today 150k downloads at 4.5★, 50k active/month.',
        body: 'Product roadmap, app live in 2 months, continuous iteration listening to real users. Web+mobile platform (quizzes, theory, document upload, payments, referral), integration with the Italian public driving portal.',
        stat1: '150k', stat1l: 'downloads',
        stat2: '4.5★', stat2l: 'store rating',
        stat3: '2 mo', stat3l: 'concept → MVP',
      },
      {
        client: 'eWibe', role: 'Fractional CTO · 2024 — present',
        title: 'Structural refactoring and stabilization of a live platform.',
        body: 'Alignment between product expectations, founders and technical debt. Performance, maintainability, stability. The hard part: saying no when needed.',
        stat1: '⤴', stat1l: 'stability',
        stat2: '−40%', stat2l: 'deploy time',
        stat3: '✓', stat3l: 'roadmap aligned',
      },
      {
        client: 'GoVolt Mobility', role: 'Eng Manager · 2022 — 2024',
        title: 'Remote engineering team built from zero (6+), GCP cloud infrastructure, scalable microservices for logistics. From strategy to execution.',
        body: 'Microservice architecture for routing, battery swap, maintenance and analytics. 6+ engineers hired and managed remote. ETL pipelines and operational dashboards.',
        stat1: '6+', stat1l: 'engineers hired',
        stat2: 'GCP', stat2l: 'microservices',
        stat3: '0→1', stat3l: 'team from zero',
      },
    ],

    testimonialsKicker: '05 — What they say',
    testimonials: [
      {
        quote: '[Concrete sentence on what got unblocked — to collect from eWibe founder]',
        author: 'Founder', role: 'CEO', company: 'eWibe',
        placeholder: true,
      },
      {
        quote: '[Concrete sentence on team building and infrastructure — to collect from GoVolt CEO]',
        author: 'CEO', role: 'Founder', company: 'GoVolt Mobility',
        placeholder: true,
      },
      {
        quote: '[Concrete sentence on CRM and operational impact — to collect from Federico]',
        author: 'Federico Ronzoni', role: 'Founder', company: 'Tana della Tartaruga',
        placeholder: true,
      },
    ],

    faqKicker: '07 — FAQ',
    faqIntro: 'The questions I always get.',
    faqs: [
      {
        q: 'How does it work concretely?',
        a: 'A day and a half a week inside the team, with written milestones every 30 days. Initial 3-month contract, monthly renewal after the first quarter. Flat monthly rate, no hours of code to account for. I\'m in your Slack/Linear every day, not just billable hours.',
      },
      {
        q: 'What does Fractional CTO actually mean?',
        a: 'A part-time CTO, inside the team with a clear milestone-driven mandate. You pay for decisions and direction — architecture, hires, roadmap — not for hours of code.',
      },
      {
        q: 'How many startups do you work with at once?',
        a: 'Few, by choice. The quality of my work depends on not spreading thin. I\'d rather say no than be a half-consultant.',
      },
      {
        q: 'Do you also write code?',
        a: 'Yes, when needed to unblock or to make architecture choices with my hands dirty. It\'s not the day job: the value is upstream (decisions, hires, architecture).',
      },
      {
        q: 'Do you also handle investors and due diligence?',
        a: 'Yes. Tech DD, calls with VCs, technical pitches. A big part of the job is telling tech well to people who don\'t build it.',
      },
      {
        q: 'How long does a typical engagement last?',
        a: 'Initial 3-month contract, then monthly renewal. Average engagement: 4–8 months. When I\'m no longer needed, I leave — that\'s the success, not the failure.',
      },
    ],
    footerAvailability: 'I work with a few startups at a time. If there\'s room, I\'ll tell you right away.',

    timelineKicker: 'Where I come from',
    timeline: [
      { y: '2013', t: 'Ferrari', d: 'Powertrain control · ISO 26262' },
      { y: '2017', t: 'RINA', d: 'Innovation architecture · Industry 4.0' },
      { y: '2019', t: 'GaiaGo', d: 'Tech Lead · team of 10' },
      { y: '2021', t: 'Fiscozen', d: 'Product Manager · regulated fintech' },
      { y: '2022', t: 'GoVolt', d: 'Acting CTO · team from zero' },
      { y: '2024', t: 'bartofactory', d: 'Fractional CTO · independent' },
      { y: '2025', t: 'BRUM', d: 'CTO · 200k users' },
    ],

    stackKicker: '05 — Stack',
    stackIntro: 'Pragmatic. I pick boring things that work. No hype.',
    stackGroups: [
      { g: 'Backend', items: ['Node', 'Python', 'Go', 'Postgres', 'Redis'] },
      { g: 'Frontend', items: ['React', 'Next.js', 'React Native', 'TypeScript'] },
      { g: 'Cloud', items: ['GCP', 'AWS', 'Cloudflare', 'Vercel'] },
      { g: 'Data', items: ['BigQuery', 'dbt', 'Airflow', 'Metabase'] },
      { g: 'Practice', items: ['Linear', 'Notion', 'GitHub', 'Sentry'] },
    ],

    ctaKicker: '08 — Let\'s talk',
    ctaTitle: 'Tell me what you\'re building.',
    ctaBody: 'An email, a voice note, a link to the product. In 48 hours I\'ll reply honestly: it\'s something I can help with, or not.',
    ctaButton: 'Send me an email',
    ctaAlt: 'or book a call on',

    footerLine: 'bartofactory · VAT IT12345670123 · ',
    madeIn: 'handmade · Italy',
  },
};

// ─────────────────────────────────────────────────────────────
// Custom cursor — scoped to an artboard. Tracks pointer relative to
// the artboard root; shows a dot + ring that grows over hoverable
// elements (.hoverable). No-op when pointer is outside the artboard.
// ─────────────────────────────────────────────────────────────
function useArtboardCursor(rootRef, { color = '#111', mixBlend = 'normal' } = {}) {
  const dotRef = React.useRef(null);
  const ringRef = React.useRef(null);
  const [hovering, setHovering] = React.useState(false);
  const [enlarged, setEnlarged] = React.useState(false);
  const [label, setLabel] = React.useState('');

  React.useEffect(() => {
    const root = rootRef.current;
    if (!root) return undefined;
    let raf = 0;
    let tx = 0, ty = 0;
    let dx = 0, dy = 0;

    const onMove = (e) => {
      const r = root.getBoundingClientRect();
      // ratio handles the canvas zoom level
      const ratio = r.width / root.offsetWidth || 1;
      tx = (e.clientX - r.left) / ratio;
      ty = (e.clientY - r.top) / ratio;
      const hit = e.target.closest('.hoverable');
      setEnlarged(!!hit);
      setLabel(hit ? (hit.dataset.cursorLabel || '') : '');
      if (!raf) raf = requestAnimationFrame(tick);
    };
    const tick = () => {
      raf = 0;
      dx += (tx - dx) * 0.35;
      dy += (ty - dy) * 0.35;
      if (dotRef.current) dotRef.current.style.transform = `translate(${tx}px, ${ty}px)`;
      if (ringRef.current) ringRef.current.style.transform = `translate(${dx}px, ${dy}px)`;
      if (Math.abs(tx - dx) > 0.3 || Math.abs(ty - dy) > 0.3) raf = requestAnimationFrame(tick);
    };
    const onEnter = () => setHovering(true);
    const onLeave = () => { setHovering(false); setEnlarged(false); };
    root.addEventListener('pointermove', onMove);
    root.addEventListener('pointerenter', onEnter);
    root.addEventListener('pointerleave', onLeave);
    return () => {
      cancelAnimationFrame(raf);
      root.removeEventListener('pointermove', onMove);
      root.removeEventListener('pointerenter', onEnter);
      root.removeEventListener('pointerleave', onLeave);
    };
  }, []);

  const Cursor = () => (
    <React.Fragment>
      <div ref={ringRef} style={{
        position: 'absolute', top: 0, left: 0,
        width: enlarged ? 56 : 26, height: enlarged ? 56 : 26,
        marginTop: enlarged ? -28 : -13, marginLeft: enlarged ? -28 : -13,
        borderRadius: '50%', border: 0,
        background: color,
        opacity: hovering ? (enlarged ? 1 : 0.35) : 0,
        pointerEvents: 'none', zIndex: 9998,
        transition: 'opacity .25s, width .22s cubic-bezier(.2,.7,.3,1), height .22s cubic-bezier(.2,.7,.3,1), margin .22s cubic-bezier(.2,.7,.3,1)',
        mixBlendMode: mixBlend,
      }} />
      <div ref={dotRef} style={{
        position: 'absolute', top: 0, left: 0, width: 4, height: 4, marginTop: -2, marginLeft: -2,
        borderRadius: '50%', background: color,
        opacity: hovering && !enlarged ? 1 : 0,
        pointerEvents: 'none', zIndex: 9999,
        transition: 'opacity .2s',
        mixBlendMode: mixBlend,
      }} />
    </React.Fragment>
  );
  return Cursor;
}

// ─────────────────────────────────────────────────────────────
// Lang switch — segmented control IT/EN
// ─────────────────────────────────────────────────────────────
function LangSwitch({ lang, setLang, color = '#111', activeBg, activeColor = '#fff' }) {
  return (
    <div className="hoverable" style={{
      display: 'inline-flex', alignItems: 'center', gap: 0,
      border: `1px solid ${color}`, borderRadius: 999, padding: 2,
      fontSize: 11, fontWeight: 600, letterSpacing: '0.08em', textTransform: 'uppercase',
      userSelect: 'none', cursor: 'pointer',
    }}>
      {['it', 'en'].map((k) => (
        <button key={k} onClick={(e) => { e.stopPropagation(); setLang(k); }}
          className="hoverable"
          style={{
            border: 0, background: lang === k ? (activeBg || color) : 'transparent',
            color: lang === k ? activeColor : color,
            padding: '4px 10px', borderRadius: 999, font: 'inherit', cursor: 'pointer',
            transition: 'background .2s, color .2s',
          }}>
          {k.toUpperCase()}
        </button>
      ))}
    </div>
  );
}

// Marquee — infinite horizontal scroller
function Marquee({ children, speed = 30, color = '#000', bg = 'transparent' }) {
  return (
    <div style={{ overflow: 'hidden', background: bg, color, padding: '14px 0', width: '100%' }}>
      <div style={{
        display: 'inline-flex', whiteSpace: 'nowrap', gap: 48,
        animation: `mq ${speed}s linear infinite`,
      }}>
        {Array.from({ length: 8 }).map((_, i) => (
          <span key={i} style={{ display: 'inline-flex', gap: 48, alignItems: 'center' }}>{children}</span>
        ))}
      </div>
      <style>{`@keyframes mq{from{transform:translateX(0)}to{transform:translateX(-50%)}}`}</style>
    </div>
  );
}

Object.assign(window, { COPY, useArtboardCursor, LangSwitch, Marquee });
