/* global React */
/* ===========================================================
   VOLTLAB · QUADRO DE MOTORES
   Lista de motores de uma instalação: corrente nominal,
   fator de partida, dimensionamento de cabo e corrente total.
   Tabelas extraídas da planilha CÁLCULOS.xlsx:
     · D - MOTORES → fator de partida (tipo × método)
     · D - CABOS   → ampacidade (seção × isolação × B1/B2)
   Integra-se ao barramento de projeto (Puxar / Enviar).
=========================================================== */
const { useState: useStMot, useMemo: useMemoMot } = React;

const useMotPersist = (key, initial) =>
  window.useLocalStorage ? window.useLocalStorage(key, initial) : useStMot(initial);

/* ── D - MOTORES · fator de partida (tipo de carga × método) ── */
const MOT_FATOR_PARTIDA = {
  Normal:          { DIN: 1.00, SOFT: 1.00, INVERSOR: 1.00, AUTOTRAFO: 10.0 },
  "Bomba C/Carga": { DIN: 1.50, SOFT: 1.25, INVERSOR: 1.00, AUTOTRAFO: 3.0 },
  Esteira:         { DIN: 1.20, SOFT: 1.00, INVERSOR: 1.00, AUTOTRAFO: 4.0 },
};
const MOT_TIPOS = ["Normal", "Bomba C/Carga", "Esteira"];
const MOT_METODOS = [
  { v: "DIN",       label: "Direta (DIN)" },
  { v: "SOFT",      label: "Soft-Starter" },
  { v: "INVERSOR",  label: "Inversor" },
  { v: "AUTOTRAFO", label: "Autotrafo" },
];

/* ── D - CABOS · ampacidade (mm² × isolação × instalação B1/B2) ── */
const MOT_CABOS = [
  { sec: 1.0,  iso: "PVC",  B1: 12,  B2: 12 },
  { sec: 1.5,  iso: "PVC",  B1: 17,  B2: 15 },
  { sec: 2.5,  iso: "PVC",  B1: 21,  B2: 20 },
  { sec: 4.0,  iso: "PVC",  B1: 28,  B2: 27 },
  { sec: 6.0,  iso: "PVC",  B1: 36,  B2: 34 },
  { sec: 10,   iso: "PVC",  B1: 50,  B2: 46 },
  { sec: 10,   iso: "XLPE", B1: 66,  B2: 61 },
  { sec: 16,   iso: "PVC",  B1: 68,  B2: 62 },
  { sec: 16,   iso: "XLPE", B1: 88,  B2: 82 },
  { sec: 25,   iso: "XLPE", B1: 117, B2: 105 },
  { sec: 35,   iso: "XLPE", B1: 144, B2: 128 },
  { sec: 50,   iso: "XLPE", B1: 175, B2: 154 },
  { sec: 70,   iso: "XLPE", B1: 222, B2: 194 },
  { sec: 95,   iso: "XLPE", B1: 269, B2: 233 },
  { sec: 120,  iso: "XLPE", B1: 312, B2: 268 },
  { sec: 150,  iso: "XLPE", B1: 358, B2: 307 },
  { sec: 185,  iso: "XLPE", B1: 409, B2: 350 },
  { sec: 240,  iso: "XLPE", B1: 483, B2: 413 },
  { sec: 300,  iso: "XLPE", B1: 556, B2: 474 },
];

/* corrente nominal — fator A/CV por faixa (calibrado da planilha) */
function correnteNominal(cv, V, fase) {
  const P = (parseFloat(cv) || 0) * 735.49875;          // CV → W
  if (P <= 0 || !V) return 0;
  // rendimento × fator de potência típico por faixa (W22 IR3)
  let cosfi_rend;
  if (cv <= 3)       cosfi_rend = 0.473;
  else if (cv <= 7.5) cosfi_rend = 0.52;
  else if (cv <= 15)  cosfi_rend = 0.55;
  else if (cv <= 50)  cosfi_rend = 0.567;
  else                cosfi_rend = 0.567;
  // divisor conforme o nº de fases
  const div = fase === "monofasico" ? V
            : fase === "bifasico"   ? (2 * V)
            : (Math.sqrt(3) * V);   // trifásico (padrão)
  return P / (div * cosfi_rend);
}

const MOT_FASES = [
  { v: "trifasico",  label: "Trifásico",  abbr: "3F" },
  { v: "bifasico",   label: "Bifásico",   abbr: "2F" },
  { v: "monofasico", label: "Monofásico", abbr: "1F" },
];
const faseAbbr = (f) => MOT_FASES.find(x => x.v === f)?.abbr || "3F";

/* dimensiona cabo a partir da corrente de projeto */
function dimensionarCabo(corrente, metodoInst, isolacaoMin) {
  // filtra por isolação aceita: se XLPE permitido, usa qualquer; se só PVC, restringe
  const candidatos = MOT_CABOS.filter(c => isolacaoMin === "PVC" ? true : true);
  for (const c of candidatos) {
    const amp = metodoInst === "B1" ? c.B1 : c.B2;
    if (amp >= corrente) return c;
  }
  return MOT_CABOS[MOT_CABOS.length - 1];
}

/* ── ícones ── */
const MtIc = ({ n, s = 16 }) => {
  const p = { width: s, height: s, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: 1.5, strokeLinecap: "round", strokeLinejoin: "round" };
  const d = {
    motor:  <><circle cx="12" cy="12" r="9"/><path d="M12 7v10M8.5 9.5l7 5M15.5 9.5l-7 5"/></>,
    bolt:   <path d="M13 2L4 14h7l-2 8 9-12h-7z"/>,
    cable:  <><path d="M4 4c4 0 4 8 8 8s4-8 8-8"/><path d="M4 20c4 0 4-8 8-8s4 8 8 8"/></>,
    plus:   <><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></>,
    trash:  <><polyline points="3 6 5 6 21 6"/><path d="M19 6l-1 14a2 2 0 01-2 2H8a2 2 0 01-2-2L5 6"/></>,
    dl:     <><path d="M12 3v12"/><polyline points="7 10 12 15 17 10"/><line x1="4" y1="21" x2="20" y2="21"/></>,
    reset:  <><path d="M21 12a9 9 0 11-3-6.7L21 8"/><path d="M21 3v5h-5"/></>,
    check:  <polyline points="20 6 9 17 4 12"/>,
    info:   <><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></>,
    sigma:  <path d="M18 4H6l6 8-6 8h12"/>,
    gauge:  <><path d="M12 14a2 2 0 100-4 2 2 0 000 4z"/><path d="M12 14l4-4"/><path d="M4 18a8 8 0 1116 0"/></>,
  };
  return <svg {...p}>{d[n] || null}</svg>;
};

/* ── dropdown padrão (.vl-dd) ── */
const MtDropdown = ({ value, onChange, options }) => {
  const [open, setOpen] = useStMot(false);
  const ref = React.useRef(null);
  React.useEffect(() => {
    if (!open) return;
    const h = (e) => { if (ref.current && !ref.current.contains(e.target)) setOpen(false); };
    document.addEventListener("mousedown", h);
    return () => document.removeEventListener("mousedown", h);
  }, [open]);
  const cur = options.find(o => o.value === value) || options[0];
  return (
    <div className={"vl-dd " + (open ? "is-open" : "")} ref={ref}>
      <button type="button" className="vl-dd-trigger" onClick={() => setOpen(o => !o)}>
        <span>{cur?.label}</span><span className="vl-dd-chev"/>
      </button>
      {open && (
        <div className="vl-dd-menu">
          {options.map(o => (
            <div key={o.value} className={"vl-dd-opt " + (o.value === value ? "is-sel" : "")}
                 onClick={() => { onChange(o.value); setOpen(false); }}>{o.label}</div>
          ))}
        </div>
      )}
    </div>
  );
};

const motFmt = (n, d = 1) => isFinite(n) ? n.toLocaleString("pt-BR", { minimumFractionDigits: d, maximumFractionDigits: d }) : "—";

/* motores de exemplo (da planilha) */
const MOT_SAMPLE = [
  { id: "m1", nome: "Bomba 01", cv: 100, V: 380, fase: "trifasico", tipo: "Bomba C/Carga", metodo: "SOFT", inst: "B2", iso: "XLPE" },
  { id: "m2", nome: "Bomba 02", cv: 100, V: 380, fase: "trifasico", tipo: "Bomba C/Carga", metodo: "SOFT", inst: "B2", iso: "XLPE" },
  { id: "m3", nome: "Compressor", cv: 30, V: 380, fase: "trifasico", tipo: "Bomba C/Carga", metodo: "SOFT", inst: "B2", iso: "XLPE" },
  { id: "m4", nome: "Ventilador", cv: 3, V: 380, fase: "trifasico", tipo: "Bomba C/Carga", metodo: "DIN", inst: "B2", iso: "PVC" },
  { id: "m5", nome: "Dosadora", cv: 1, V: 220, fase: "monofasico", tipo: "Bomba C/Carga", metodo: "DIN", inst: "B2", iso: "PVC" },
];

const QuadroMotores = () => {
  const [motores, setMotores] = useMotPersist("vl_quadro_motores_v1", MOT_SAMPLE);
  const [sel, setSel] = useStMot(MOT_SAMPLE[0].id);

  const rows = useMemoMot(() => motores.map(m => {
    const In = correnteNominal(m.cv, m.V, m.fase || "trifasico");
    const fp = MOT_FATOR_PARTIDA[m.tipo]?.[m.metodo] ?? 1;
    const Ipart = In * fp;
    const cabo = dimensionarCabo(In, m.inst, m.iso);
    const amp = m.inst === "B1" ? cabo.B1 : cabo.B2;
    return { ...m, In, fp, Ipart, cabo, amp };
  }), [motores]);

  const totals = useMemoMot(() => {
    const In = rows.reduce((s, r) => s + r.In, 0);
    const pot = rows.reduce((s, r) => s + (parseFloat(r.cv) || 0), 0);
    const potKW = pot * 0.73549875;
    const maiorPartida = rows.reduce((mx, r) => r.Ipart > mx.Ipart ? r : mx, { Ipart: 0 });
    // corrente de pico (maior partida + nominal dos demais) — dimensionamento do barramento
    const pico = maiorPartida.Ipart > 0 ? (In - maiorPartida.In) + maiorPartida.Ipart : In;
    return { In, pot, potKW, maiorPartida, pico };
  }, [rows]);

  const selM = rows.find(r => r.id === sel) || rows[0];

  const add = () => {
    const m = { id: "m" + Date.now(), nome: "Motor " + (motores.length + 1), cv: 5, V: 380, fase: "trifasico", tipo: "Normal", metodo: "DIN", inst: "B2", iso: "PVC" };
    setMotores([...motores, m]); setSel(m.id);
  };
  const upd = (id, patch) => setMotores(motores.map(m => m.id === id ? { ...m, ...patch } : m));
  const del = (id) => { setMotores(motores.filter(m => m.id !== id)); if (sel === id) setSel(null); };
  const reset = () => { setMotores(MOT_SAMPLE); setSel(MOT_SAMPLE[0].id); if (window.vlToast) window.vlToast("✓ Restaurado"); };

  const exportCSV = () => {
    const head = ["NOME","POT(CV)","TENSAO(V)","FASE","TIPO","METODO","In(A)","FATOR PARTIDA","Ipart(A)","INSTAL","CABO(mm2)","ISOLACAO","AMPACIDADE(A)"];
    const lines = [head.join(";")];
    rows.forEach(r => lines.push([r.nome, r.cv, r.V, faseAbbr(r.fase), r.tipo, r.metodo, r.In.toFixed(1), r.fp, r.Ipart.toFixed(1), r.inst, r.cabo.sec, r.cabo.iso, r.amp].join(";")));
    lines.push("");
    lines.push(["TOTAL In (A)", totals.In.toFixed(1)].join(";"));
    lines.push(["Corrente de pico (A)", totals.pico.toFixed(1)].join(";"));
    lines.push(["Potencia total (kW)", totals.potKW.toFixed(1)].join(";"));
    const a = document.createElement("a");
    a.href = URL.createObjectURL(new Blob(["\uFEFF" + lines.join("\n")], { type: "text/csv;charset=utf-8" }));
    a.download = "quadro-motores.csv"; a.click();
    if (window.vlToast) window.vlToast("✓ CSV exportado");
  };

  const Sync = window.VL_ProjetoSync;

  return (
    <div className="eletroduto">
      <div className="el-grid" style={{ gridTemplateColumns: "1.55fr 1fr" }}>
        {/* ───────── LISTA DE MOTORES ───────── */}
        <section className="panel">
          <div className="panel-head">
            <div>
              <div className="panel-eyebrow">ENTRADA · LISTA DE MOTORES</div>
              <h3>Quadro de cargas motrizes</h3>
            </div>
            <div className="status-chip"><span className="status-dot status-ok"/>AUTO</div>
          </div>

          {Sync && <Sync
            source="Quadro de Motores"
            reads={["tensao","sistema"]}
            pull={(s) => { const t = s.get("tensao"); const sis = s.get("sistema"); setMotores(motores.map(m => ({ ...m, ...(t!=null?{V:parseFloat(t)}:{}), ...(sis?{fase:sis}:{}) }))); }}
            push={() => ({ tensao: parseFloat(selM?.V) || undefined, sistema: selM?.fase, corrente: +totals.In.toFixed(2), potencia: +totals.potKW.toFixed(3) })}
          />}

          <div className="vl-mot-table">
            <div className="vl-mot-row vl-mot-head">
              <span>MOTOR</span><span>CV</span><span>PARTIDA</span><span>In (A)</span><span>CABO</span><span/>
            </div>
            {rows.map(r => (
              <div key={r.id} className={"vl-mot-row " + (sel === r.id ? "is-sel" : "")} onClick={() => setSel(r.id)}>
                <div className="vl-mot-name">
                  <span className="vl-mot-ic"><MtIc n="motor" s={15}/></span>
                  <div className="vl-mot-name-meta">
                    <b>{r.nome}</b>
                    <em>{faseAbbr(r.fase)} · {r.tipo} · {r.V} V</em>
                  </div>
                </div>
                <span className="mono vl-mot-cv">{r.cv}</span>
                <span className="vl-mot-part">{r.metodo}</span>
                <span className="mono vl-mot-in">{motFmt(r.In)}</span>
                <span className="vl-mot-cabo">
                  <b className="mono">{r.cabo.sec}</b>
                  <em>{r.cabo.iso} · {r.inst}</em>
                </span>
                <button className="vl-mot-del" onClick={(e) => { e.stopPropagation(); del(r.id); }} aria-label="remover">×</button>
              </div>
            ))}
          </div>

          <div className="vl-mot-toolbar">
            <button className="btn btn-primary" onClick={add}><MtIc n="plus" s={14}/> Adicionar motor</button>
            <button className="btn btn-ghost" onClick={reset}><MtIc n="reset" s={14}/> Exemplo</button>
            <button className="btn btn-ghost" onClick={exportCSV}><MtIc n="dl" s={14}/> CSV</button>
          </div>

          {/* totalizadores */}
          <div className="vl-quick-stats" style={{ marginTop: 18 }}>
            <div><span>Motores</span><b className="readout">{String(rows.length).padStart(2, "0")}</b></div>
            <div><span>Corrente total In</span><b className="readout">{motFmt(totals.In)} A</b></div>
            <div><span>Potência instalada</span><b className="readout">{motFmt(totals.potKW)} kW</b></div>
          </div>
        </section>

        {/* ───────── DETALHE DO MOTOR SELECIONADO ───────── */}
        <aside className="panel el-result">
          <div className="panel-head">
            <div>
              <div className="panel-eyebrow">DETALHE · MOTOR SELECIONADO</div>
              <h3>{selM ? selM.nome : "—"}</h3>
              {selM && <span className="dim mono small">{MOT_FASES.find(f=>f.v===(selM.fase||"trifasico"))?.label} · {selM.V} V</span>}
            </div>
          </div>

          {selM ? (
            <>
              {/* editor do motor */}
              <div className="vl-mot-edit">
                <div className="vl-field">
                  <label className="vl-field-label"><span>Identificação</span></label>
                  <div className="vl-input"><input type="text" value={selM.nome} onChange={e => upd(selM.id, { nome: e.target.value })}/></div>
                </div>
                <div className="form-row form-row-2">
                  <div className="vl-field">
                    <label className="vl-field-label"><span>Potência</span></label>
                    <div className="vl-input"><input type="number" value={selM.cv} step="0.5" min="0" onChange={e => upd(selM.id, { cv: e.target.value })}/><span className="vl-input-suffix">CV</span></div>
                  </div>
                  <div className="vl-field">
                    <label className="vl-field-label"><span>Tensão</span></label>
                    <div className="vl-input"><input type="number" value={selM.V} step="1" onChange={e => upd(selM.id, { V: e.target.value })}/><span className="vl-input-suffix">V</span></div>
                  </div>
                </div>
                <div className="vl-field">
                  <label className="vl-field-label"><span>Tipo de alimentação</span></label>
                  <div className="seg">
                    {MOT_FASES.map(f => (
                      <button key={f.v} className={(selM.fase||"trifasico")===f.v?"is-active":""} onClick={()=>upd(selM.id,{fase:f.v})}>{f.label}</button>
                    ))}
                  </div>
                </div>
                <div className="vl-field">
                  <label className="vl-field-label"><span>Tipo de carga</span></label>
                  <MtDropdown value={selM.tipo} onChange={v => upd(selM.id, { tipo: v })}
                    options={MOT_TIPOS.map(t => ({ value: t, label: t }))}/>
                </div>
                <div className="vl-field">
                  <label className="vl-field-label"><span>Método de partida</span></label>
                  <MtDropdown value={selM.metodo} onChange={v => upd(selM.id, { metodo: v })}
                    options={MOT_METODOS.map(t => ({ value: t.v, label: t.label }))}/>
                </div>
                <div className="form-row form-row-2">
                  <div className="vl-field">
                    <label className="vl-field-label"><span>Instalação</span></label>
                    <div className="seg">
                      {["B1","B2"].map(o => <button key={o} className={selM.inst===o?"is-active":""} onClick={()=>upd(selM.id,{inst:o})}>{o}</button>)}
                    </div>
                  </div>
                  <div className="vl-field">
                    <label className="vl-field-label"><span>Isolação</span></label>
                    <div className="seg">
                      {["PVC","XLPE"].map(o => <button key={o} className={selM.iso===o?"is-active":""} onClick={()=>upd(selM.id,{iso:o})}>{o}</button>)}
                    </div>
                  </div>
                </div>
              </div>

              {/* resultado do motor */}
              <div className="vl-result-big" style={{ marginTop: 16 }}>
                <div className="vl-result-corner vl-result-corner-tl"/>
                <div className="vl-result-corner vl-result-corner-tr"/>
                <div className="vl-result-corner vl-result-corner-bl"/>
                <div className="vl-result-corner vl-result-corner-br"/>
                <div className="vl-result-label">CABO RECOMENDADO</div>
                <div className="vl-result-row">
                  <span className="readout vl-result-val">{selM.cabo.sec}</span>
                  <em>mm² {selM.cabo.iso}</em>
                </div>
              </div>

              <div className="vl-mini-grid vl-mini-grid-3">
                <div className="vl-metric"><div className="vl-metric-label">CORRENTE In</div><div className="vl-metric-value"><span className="readout">{motFmt(selM.In)}</span><em>A</em></div></div>
                <div className="vl-metric"><div className="vl-metric-label">FATOR PARTIDA</div><div className="vl-metric-value"><span className="readout">{motFmt(selM.fp, 2)}</span><em>×</em></div></div>
                <div className="vl-metric"><div className="vl-metric-label">I. PARTIDA</div><div className="vl-metric-value"><span className="readout">{motFmt(selM.Ipart)}</span><em>A</em></div></div>
              </div>

              <div className="vl-banner vl-banner-ok" style={{ marginTop: 4 }}>
                <MtIc n="check" s={16}/>
                <span>Cabo {selM.cabo.sec} mm² {selM.cabo.iso} ({selM.inst}) suporta {selM.amp} A &ge; {motFmt(selM.In)} A</span>
              </div>
            </>
          ) : (
            <div className="vl-banner vl-banner-info"><MtIc n="info" s={16}/><span>Selecione um motor na lista.</span></div>
          )}
        </aside>
      </div>

      {/* ───────── DIMENSIONAMENTO DO BARRAMENTO / TOTAL ───────── */}
      <section className="panel">
        <div className="panel-head">
          <div>
            <div className="panel-eyebrow">DIMENSIONAMENTO GLOBAL · QUADRO</div>
            <h3>Corrente de projeto do alimentador geral</h3>
          </div>
          <span className="dim mono small">pico = Σ In + (fator partida − 1)·maior motor</span>
        </div>
        <div className="vl-mini-grid" style={{ gridTemplateColumns: "repeat(4,1fr)" }}>
          <div className="vl-metric"><div className="vl-metric-label">CORRENTE NOMINAL Σ</div><div className="vl-metric-value is-big"><span className="readout">{motFmt(totals.In)}</span><em>A</em></div></div>
          <div className="vl-metric"><div className="vl-metric-label">CORRENTE DE PICO</div><div className="vl-metric-value is-big"><span className="readout">{motFmt(totals.pico)}</span><em>A</em></div></div>
          <div className="vl-metric"><div className="vl-metric-label">MAIOR PARTIDA</div><div className="vl-metric-value is-big"><span className="readout">{totals.maiorPartida?.nome ? motFmt(totals.maiorPartida.Ipart) : "—"}</span><em>A</em></div></div>
          <div className="vl-metric"><div className="vl-metric-label">POTÊNCIA TOTAL</div><div className="vl-metric-value is-big"><span className="readout">{motFmt(totals.potKW)}</span><em>kW</em></div></div>
        </div>
        <div className="vl-banner vl-banner-info" style={{ marginTop: 14 }}>
          <MtIc n="info" s={16}/>
          <span>
            Disjuntor geral sugerido ≥ <b>{Math.ceil(totals.pico / 5) * 5} A</b>
            {totals.maiorPartida?.nome ? ` · maior partida: ${totals.maiorPartida.nome} (${totals.maiorPartida.metodo})` : ""}
          </span>
        </div>
      </section>

      {/* ───────── TABELAS DE REFERÊNCIA ───────── */}
      <div className="el-grid" style={{ gridTemplateColumns: "1fr 1fr" }}>
        <section className="panel">
          <div className="panel-head">
            <div>
              <div className="panel-eyebrow">REFERÊNCIA · FATOR DE PARTIDA</div>
              <h3>Tipo de carga × método</h3>
            </div>
            <span className="dim mono small">D-MOTORES</span>
          </div>
          <div className="ref-table vl-mot-fp-ref">
            <div className="ref-head">
              <span>TIPO</span><span>DIN</span><span>SOFT</span><span>INVERSOR</span><span>AUTOTRAFO</span>
            </div>
            {MOT_TIPOS.map(t => (
              <div key={t} className={"ref-row " + (selM?.tipo === t ? "is-sel" : "")}>
                <span>{t}</span>
                {["DIN","SOFT","INVERSOR","AUTOTRAFO"].map(mt => (
                  <span key={mt} className={"mono " + (selM?.tipo === t && selM?.metodo === mt ? "" : "dim")}>
                    {MOT_FATOR_PARTIDA[t][mt].toFixed(2)}
                  </span>
                ))}
              </div>
            ))}
          </div>
        </section>

        <section className="panel">
          <div className="panel-head">
            <div>
              <div className="panel-eyebrow">REFERÊNCIA · AMPACIDADE</div>
              <h3>Seção × isolação × instalação</h3>
            </div>
            <span className="dim mono small">D-CABOS · A</span>
          </div>
          <div className="ref-table vl-mot-cabo-ref" style={{ maxHeight: 320, overflowY: "auto" }}>
            <div className="ref-head">
              <span>SEÇÃO (mm²)</span><span>ISOLAÇÃO</span><span>B1 (A)</span><span>B2 (A)</span>
            </div>
            {MOT_CABOS.map((c, i) => {
              const isSel = selM && selM.cabo.sec === c.sec && selM.cabo.iso === c.iso;
              return (
                <div key={i} className={"ref-row " + (isSel ? "is-sel" : "")}>
                  <span className="mono"><b>{c.sec}</b></span>
                  <span className="dim">{c.iso}</span>
                  <span className={"mono " + (selM?.inst === "B1" ? "" : "dim")}>{c.B1}</span>
                  <span className={"mono " + (selM?.inst === "B2" ? "" : "dim")}>{c.B2}</span>
                </div>
              );
            })}
          </div>
        </section>
      </div>
    </div>
  );
};

window.VL_QuadroMotores = QuadroMotores;