import { describe, expect, it } from "vitest";
import JSZip from "jszip";
import {
  buildChartXml,
  buildCellXml,
  buildAutoFilterXml,
  buildCommentsXml,
  buildColumnWidthsXml,
  buildHyperlinksXml,
  buildMergeCellsXml,
  buildSheetPrXml,
  buildSheetViewsXml,
  createCellStyleRegistry,
  buildWorksheetRelationshipsXml,
  buildWorksheetXml,
  exportXlsxBlob,
  importXlsxFile,
  chartDataPoints,
  chartXmlToSheetChart,
  workbookActiveSheetId,
  workbookPrintAreas,
  workbookRelationshipTargets,
  workbookSheetRefs,
  workbookUsesDate1904,
  worksheetXmlToAutoFilter,
  worksheetXmlToCells,
  worksheetXmlToCellFormats,
  worksheetXmlToColumnWidths,
  worksheetXmlToFrozenPane,
  worksheetXmlToHiddenColumns,
  worksheetXmlToHiddenRows,
  worksheetXmlToHyperlinks,
  worksheetCommentsXmlToComments,
  worksheetXmlToMergedCells,
  worksheetXmlToRowHeights,
  worksheetXmlToShowGridLines,
  worksheetXmlToTabColor,
  worksheetXmlToZoomScale,
  xlsxStylesXmlToCellFormatTable,
  xlsxThemeXmlToColors,
  xlsxSafeSheetNames,
  xlsxCellToText
} from "./excellOffice";

describe("excellOffice OOXML helpers", () => {
  it("сохраняет формулу при импорте как строку с '='", () => {
    expect(xlsxCellToText({ r: "C1", f: "SUM(A1:B1)", v: "3" }, [])).toBe("=SUM(A1:B1)");
    expect(xlsxCellToText({ r: "C2", f: { "#text": "A2*2" }, v: "8" }, [])).toBe("=A2*2");
  });

  it("сдвигает относительные ссылки XLSX shared formulas при импорте", () => {
    const cells = worksheetXmlToCells(
      {
        worksheet: {
          sheetData: {
            row: [
              {
                r: "1",
                c: [{ r: "C1", f: { t: "shared", si: "0", ref: "C1:D2", "#text": "A1+B$1+$A1+$B$2+'A1 Sheet'!A1&\"A1\"" }, v: "0" }]
              },
              {
                r: "2",
                c: [
                  { r: "C2", f: { t: "shared", si: "0" }, v: "0" },
                  { r: "D2", f: { t: "shared", si: "0" }, v: "0" }
                ]
              }
            ]
          }
        }
      },
      []
    );

    expect(cells).toEqual({
      C1: "=A1+B$1+$A1+$B$2+'A1 Sheet'!A1&\"A1\"",
      C2: "=A2+B$1+$A2+$B$2+'A1 Sheet'!A2&\"A1\"",
      D2: "=B2+C$1+$A2+$B$2+'A1 Sheet'!B2&\"A1\""
    });
  });

  it("читает shared string, inline string, число и boolean", () => {
    expect(xlsxCellToText({ r: "A1", t: "s", v: "1" }, ["Первый", "Второй"])).toBe("Второй");
    expect(xlsxCellToText({ r: "A2", t: "inlineStr", is: { t: "Текст" } }, [])).toBe("Текст");
    expect(xlsxCellToText({ r: "A3", v: "12500" }, [])).toBe("12500");
    expect(xlsxCellToText({ r: "A4", t: "b", v: "1" }, [])).toBe("true");
  });

  it("записывает формулу в тег <f>", () => {
    expect(buildCellXml("c1", "=SUM(A1:B1)")).toBe('<c r="C1"><f>SUM(A1:B1)</f></c>');
  });

  it("собирает XML листа с отсортированными ячейками", () => {
    const xml = buildWorksheetXml({
      B2: "200",
      A1: "Статья",
      C2: "=B2*2"
    });

    expect(xml).toContain('<row r="1"><c r="A1" t="inlineStr"><is><t>Статья</t></is></c></row>');
    expect(xml).toContain('<row r="2"><c r="B2"><v>200</v></c><c r="C2"><f>B2*2</f></c></row>');
  });

  it("сохраняет merged cells в XML листа", () => {
    const xml = buildWorksheetXml({ A1: "Заголовок" }, [{ start: "A1", end: "C2" }]);

    expect(buildMergeCellsXml([{ start: "C2", end: "A1" }, { start: "A1", end: "C2" }])).toBe(
      '<mergeCells count="1"><mergeCell ref="A1:C2"/></mergeCells>'
    );
    expect(xml).toContain('<mergeCells count="1"><mergeCell ref="A1:C2"/></mergeCells>');
  });

  it("сохраняет внешние гиперссылки XLSX в XML листа и relationships", () => {
    const hyperlinks = {
      A1: "https://example.com/report",
      B2: "javascript:alert(1)"
    };
    const xml = buildWorksheetXml({ A1: "Отчет", B2: "Скрипт" }, [], hyperlinks);
    const relationshipsXml = buildWorksheetRelationshipsXml(hyperlinks);

    expect(buildHyperlinksXml(hyperlinks)).toBe('<hyperlinks><hyperlink ref="A1" r:id="rId1"/></hyperlinks>');
    expect(xml).toContain('<hyperlinks><hyperlink ref="A1" r:id="rId1"/></hyperlinks>');
    expect(relationshipsXml).toContain('Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"');
    expect(relationshipsXml).toContain('Target="https://example.com/report"');
    expect(relationshipsXml).toContain('TargetMode="External"');
    expect(relationshipsXml).not.toContain("javascript:alert");
  });

  it("сохраняет внутренние гиперссылки XLSX как location без external relationship", () => {
    const hyperlinks = {
      A1: "#Справочник!B2",
      B2: "https://example.com/report"
    };
    const xml = buildWorksheetXml({ A1: "Справочник", B2: "Отчет" }, [], hyperlinks);
    const relationshipsXml = buildWorksheetRelationshipsXml(hyperlinks);

    expect(buildHyperlinksXml(hyperlinks)).toBe(
      '<hyperlinks><hyperlink ref="A1" location="Справочник!B2"/><hyperlink ref="B2" r:id="rId1"/></hyperlinks>'
    );
    expect(xml).toContain('<hyperlink ref="A1" location="Справочник!B2"/>');
    expect(relationshipsXml).toContain('Target="https://example.com/report"');
    expect(relationshipsXml).not.toContain("Справочник!B2");
  });

  it("назначает drawing relationship после внешних ссылок, игнорируя внутренние ссылки XLSX", () => {
    const relationshipsXml = buildWorksheetRelationshipsXml({ A1: "#Справочник!B2" }, "../drawings/drawing1.xml");

    expect(relationshipsXml).toContain('Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing"');
    expect(relationshipsXml).not.toContain('TargetMode="External"');
  });

  it("собирает и читает legacy comments XLSX для заметок ячеек", () => {
    const commentsXml = buildCommentsXml({ B2: "Проверить сумму", A1: "Комментарий\nв две строки" });
    const parsedComments = worksheetCommentsXmlToComments({
      comments: {
        commentList: {
          comment: [
            { ref: "B2", text: { t: "Проверить сумму" } },
            { ref: "A1", text: { r: [{ t: "Комментарий" }, { t: "\nв две строки" }] } }
          ]
        }
      }
    });

    expect(commentsXml).toContain('<comment ref="A1" authorId="0"><text><t>Комментарий\nв две строки</t></text></comment>');
    expect(commentsXml).toContain('<comment ref="B2" authorId="0"><text><t>Проверить сумму</t></text></comment>');
    expect(parsedComments).toEqual({ A1: "Комментарий\nв две строки", B2: "Проверить сумму" });
  });

  it("сохраняет заметки ячеек XLSX в comments, VML и relationships", async () => {
    const blob = await exportXlsxBlob({
      id: "workbook",
      title: "Comments.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Sheet 1",
          cells: { A1: "Итого" },
          comments: { A1: "Проверено финансовым отделом" }
        }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const contentTypesXml = await zip.file("[Content_Types].xml")?.async("string");
    const worksheetXml = await zip.file("xl/worksheets/sheet1.xml")?.async("string");
    const relationshipsXml = await zip.file("xl/worksheets/_rels/sheet1.xml.rels")?.async("string");
    const commentsXml = await zip.file("xl/comments1.xml")?.async("string");
    const vmlXml = await zip.file("xl/drawings/vmlDrawing1.vml")?.async("string");
    const imported = await importXlsxFile(new File([blob], "Comments.xlsx", { type: blob.type }));

    expect(contentTypesXml).toContain("/xl/comments1.xml");
    expect(contentTypesXml).toContain('Extension="vml"');
    expect(worksheetXml).toContain('<legacyDrawing r:id="rId2"/>');
    expect(relationshipsXml).toContain('Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments"');
    expect(relationshipsXml).toContain('Target="../comments1.xml"');
    expect(relationshipsXml).toContain('Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing"');
    expect(commentsXml).toContain('<comment ref="A1" authorId="0">');
    expect(vmlXml).toContain("<x:Row>0</x:Row><x:Column>0</x:Column>");
    expect(imported.sheets[0].comments).toEqual({ A1: "Проверено финансовым отделом" });
  });

  it("сохраняет базовое форматирование ячеек XLSX в XML листа", () => {
    const cellFormats = {
      A1: { bold: true, fontSize: 14, fontFamily: "Arial", textColor: "0f5fae", fillColor: "fff2cc", horizontalAlign: "center" as const },
      B2: { italics: true, underline: true, strike: true },
      C3: { fillColor: "bad-color" }
    };
    const registry = createCellStyleRegistry([cellFormats]);
    const xml = buildWorksheetXml({ A1: "Итог", B2: "Комментарий", C3: "Без стиля" }, [], {}, cellFormats, registry);
    const emptyCellXml = buildWorksheetXml({}, [], {}, { C3: { underline: true } });

    expect(xml).toContain('<c r="A1" s="1" t="inlineStr"><is><t>Итог</t></is></c>');
    expect(xml).toContain('<c r="B2" s="2" t="inlineStr"><is><t>Комментарий</t></is></c>');
    expect(xml).toContain('<c r="C3" t="inlineStr"><is><t>Без стиля</t></is></c>');
    expect(emptyCellXml).toContain('<c r="C3" s="1"/>');
  });

  it("записывает зачеркивание ячейки XLSX в styles.xml", async () => {
    const blob = await exportXlsxBlob({
      id: "workbook",
      title: "Strike.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Sheet 1",
          cells: { A1: "Deleted" },
          cellFormats: { A1: { strike: true } }
        }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const stylesXml = await zip.file("xl/styles.xml")?.async("string");

    expect(stylesXml).toContain("<strike/>");
  });

  it("записывает семейство шрифта ячейки XLSX в styles.xml", async () => {
    const blob = await exportXlsxBlob({
      id: "workbook",
      title: "Font.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Sheet 1",
          cells: { A1: "Arial" },
          cellFormats: { A1: { fontFamily: "Arial" } }
        }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const stylesXml = await zip.file("xl/styles.xml")?.async("string");

    expect(stylesXml).toContain('<name val="Arial"/>');
  });

  it("записывает перенос текста ячейки XLSX в styles.xml", async () => {
    const blob = await exportXlsxBlob({
      id: "workbook",
      title: "Wrap.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Sheet 1",
          cells: { A1: "Long text" },
          cellFormats: { A1: { wrapText: true } }
        }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const stylesXml = await zip.file("xl/styles.xml")?.async("string");

    expect(stylesXml).toContain('applyAlignment="1"');
    expect(stylesXml).toContain('wrapText="1"');
  });

  it("записывает вертикальное выравнивание ячейки XLSX в styles.xml", async () => {
    const blob = await exportXlsxBlob({
      id: "workbook",
      title: "VerticalAlign.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Sheet 1",
          cells: { A1: "Centered" },
          cellFormats: { A1: { verticalAlign: "middle" } }
        }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const stylesXml = await zip.file("xl/styles.xml")?.async("string");

    expect(stylesXml).toContain('applyAlignment="1"');
    expect(stylesXml).toContain('vertical="center"');
  });

  it("записывает границы ячейки XLSX в styles.xml", async () => {
    const blob = await exportXlsxBlob({
      id: "workbook",
      title: "Borders.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Sheet 1",
          cells: { A1: "Bordered" },
          cellFormats: { A1: { border: true, borderColor: "C2410C" } }
        }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const stylesXml = await zip.file("xl/styles.xml")?.async("string");

    expect(stylesXml).toContain('<borders count="2">');
    expect(stylesXml).toContain('applyBorder="1"');
    expect(stylesXml).toContain('<left style="thin">');
    expect(stylesXml).toContain('<right style="thin">');
    expect(stylesXml).toContain('<top style="thin">');
    expect(stylesXml).toContain('<bottom style="thin">');
    expect(stylesXml).toContain('<color rgb="FFC2410C"/>');
  });

  it("читает базовое форматирование ячеек XLSX из styles.xml и XML листа", () => {
    const styleTable = xlsxStylesXmlToCellFormatTable({
      styleSheet: {
        numFmts: {
          numFmt: { numFmtId: "164", formatCode: "dd.mm.yyyy" }
        },
        fonts: {
          font: [{}, { b: {}, i: {}, u: {}, strike: {}, sz: { val: "14" }, name: { val: "Arial" }, color: { rgb: "FF0F5FAE" } }]
        },
        fills: {
          fill: [{}, {}, { patternFill: { fgColor: { rgb: "FFFFF2CC" } } }]
        },
        borders: {
          border: [
            {},
            {
              left: { style: "thin", color: { rgb: "FFC2410C" } },
              right: { style: "thin", color: { rgb: "FFC2410C" } },
              top: { style: "thin", color: { rgb: "FFC2410C" } },
              bottom: { style: "thin", color: { rgb: "FFC2410C" } }
            }
          ]
        },
        cellXfs: {
          xf: [
            { fontId: "0", fillId: "0" },
            { fontId: "1", fillId: "2", borderId: "1", numFmtId: "164", alignment: { horizontal: "center", vertical: "center", wrapText: "1" } },
            { fontId: "0", fillId: "0", numFmtId: "14" }
          ]
        }
      }
    });

    expect(styleTable[1]).toEqual({
      bold: true,
      italics: true,
      underline: true,
      strike: true,
      fontSize: 14,
      fontFamily: "Arial",
      textColor: "0F5FAE",
      fillColor: "FFF2CC",
      horizontalAlign: "center",
      verticalAlign: "middle",
      wrapText: true,
      border: true,
      borderColor: "C2410C",
      numberFormat: "dd.mm.yyyy"
    });
    expect(styleTable[2]).toEqual({ numberFormat: "m/d/yy" });
    expect(
      worksheetXmlToCellFormats(
        {
          worksheet: {
            sheetData: {
              row: {
                r: "1",
                c: [{ r: "A1", s: "1", t: "inlineStr", is: { t: "Итог" } }]
              }
            }
          }
        },
        styleTable
      )
    ).toEqual({
      A1: {
        bold: true,
        italics: true,
        underline: true,
        strike: true,
        fontSize: 14,
        fontFamily: "Arial",
        textColor: "0F5FAE",
        fillColor: "FFF2CC",
        horizontalAlign: "center",
        verticalAlign: "middle",
        wrapText: true,
        border: true,
        borderColor: "C2410C",
        numberFormat: "dd.mm.yyyy"
      }
    });
  });

  it("читает theme, tint и indexed цвета XLSX из styles.xml", () => {
    const styleTable = xlsxStylesXmlToCellFormatTable({
      styleSheet: {
        fonts: {
          font: [{ color: { theme: "1" } }, { color: { theme: "4", tint: "0.5" } }, { color: { indexed: "22" } }]
        },
        fills: {
          fill: [{}, {}, { patternFill: { fgColor: { theme: "6" } } }]
        },
        borders: {
          border: [{}, { left: { style: "thin", color: { indexed: "4" } } }]
        },
        cellXfs: {
          xf: [
            { fontId: "0", fillId: "0", borderId: "0" },
            { fontId: "1", fillId: "2", borderId: "1" },
            { fontId: "2", fillId: "0", borderId: "0" }
          ]
        }
      }
    });

    expect(styleTable[0]).toBeUndefined();
    expect(styleTable[1]).toEqual({
      textColor: "A7C0DE",
      fillColor: "9BBB59",
      border: true,
      borderColor: "0000FF"
    });
    expect(styleTable[2]).toEqual({ textColor: "C0C0C0" });
  });

  it("использует цвета из xl/theme/theme1.xml при импорте XLSX", async () => {
    const themeXml = `<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"><a:themeElements><a:clrScheme name="Custom"><a:dk1><a:srgbClr val="000000"/></a:dk1><a:lt1><a:srgbClr val="FFFFFF"/></a:lt1><a:dk2><a:srgbClr val="222222"/></a:dk2><a:lt2><a:srgbClr val="EEEEEE"/></a:lt2><a:accent1><a:srgbClr val="123456"/></a:accent1></a:clrScheme></a:themeElements></a:theme>`;
    const zip = new JSZip();
    zip.file("xl/workbook.xml", `<workbook><sheets><sheet name="Theme" sheetId="1" r:id="rId1"/></sheets></workbook>`);
    zip.file(
      "xl/_rels/workbook.xml.rels",
      `<Relationships><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/><Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/><Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme" Target="theme/theme1.xml"/></Relationships>`
    );
    zip.file("xl/theme/theme1.xml", themeXml);
    zip.file(
      "xl/styles.xml",
      `<styleSheet><fonts count="2"><font/><font><color theme="4"/><name val="Calibri"/></font></fonts><fills count="1"><fill><patternFill patternType="none"/></fill></fills><borders count="1"><border><left/><right/><top/><bottom/><diagonal/></border></borders><cellXfs count="2"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/><xf numFmtId="0" fontId="1" fillId="0" borderId="0"/></cellXfs></styleSheet>`
    );
    zip.file(
      "xl/worksheets/sheet1.xml",
      `<worksheet><sheetData><row r="1"><c r="A1" s="1" t="inlineStr"><is><t>Themed</t></is></c></row></sheetData></worksheet>`
    );

    expect(xlsxThemeXmlToColors({ "a:theme": { "a:themeElements": { "a:clrScheme": { "a:accent1": { "a:srgbClr": { val: "123456" } } } } } })[4]).toBe(
      "123456"
    );

    const blob = await zip.generateAsync({
      type: "blob",
      mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
    });
    const imported = await importXlsxFile(new File([blob], "Theme.xlsx", { type: blob.type }));

    expect(imported.sheets[0].cellFormats).toEqual({
      A1: { textColor: "123456" }
    });
  });

  it("преобразует XML листа в модель QExcell", () => {
    const cells = worksheetXmlToCells(
      {
        worksheet: {
          sheetData: {
            row: {
              r: "1",
              c: [
                { r: "A1", t: "inlineStr", is: { t: "Статья" } },
                { r: "B1", v: "1000" },
                { r: "C1", f: "B1*2" }
              ]
            }
          }
        }
      },
      []
    );

    expect(cells).toEqual({
      A1: "Статья",
      B1: "1000",
      C1: "=B1*2"
    });
  });

  it("читает merged cells из XML листа", () => {
    expect(
      worksheetXmlToMergedCells({
        worksheet: {
          mergeCells: {
            mergeCell: [{ ref: "C2:A1" }, { ref: "D4:D4" }, { ref: "bad" }]
          }
        }
      })
    ).toEqual([{ start: "A1", end: "C2" }]);
  });

  it("читает внешние гиперссылки XLSX из XML листа и relationships", () => {
    expect(
      worksheetXmlToHyperlinks(
        {
          worksheet: {
            hyperlinks: {
              hyperlink: [
                { ref: "A1", "r:id": "rIdLink" },
                { ref: "B2", "r:id": "rIdUnsafe" },
                { ref: "bad", "r:id": "rIdLink" }
              ]
            }
          }
        },
        {
          Relationships: {
            Relationship: [
              {
                Id: "rIdLink",
                Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
                Target: "https://example.com/report",
                TargetMode: "External"
              },
              {
                Id: "rIdUnsafe",
                Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
                Target: "javascript:alert(1)",
                TargetMode: "External"
              }
            ]
          }
        }
      )
    ).toEqual({ A1: "https://example.com/report" });
  });

  it("читает внутренние гиперссылки XLSX из location", () => {
    expect(
      worksheetXmlToHyperlinks(
        {
          worksheet: {
            hyperlinks: {
              hyperlink: [
                { ref: "A1", location: "Справочник!B2" },
                { ref: "B2", location: "" },
                { ref: "bad", location: "Справочник!B2" }
              ]
            }
          }
        },
        undefined
      )
    ).toEqual({ A1: "#Справочник!B2" });
  });

  it("читает ссылки листов и relationships из workbook XML", () => {
    expect(
      workbookSheetRefs({
        workbook: {
          sheets: {
            sheet: { name: "Бюджет", sheetId: "7", "r:id": "rId3" }
          }
        }
      })
    ).toEqual([{ id: "sheet-7", name: "Бюджет", relationshipId: "rId3" }]);

    expect(
      workbookSheetRefs({
        workbook: {
          sheets: {
            sheet: { name: "Архив", sheetId: "8", "r:id": "rId4", state: "hidden" }
          }
        }
      })
    ).toEqual([{ id: "sheet-8", name: "Архив", visibility: "hidden", relationshipId: "rId4" }]);

    expect(
      workbookRelationshipTargets({
        Relationships: {
          Relationship: [{ Id: "rId3", Target: "worksheets/sheet7.xml" }]
        }
      })
    ).toEqual({ rId3: "worksheets/sheet7.xml" });

    expect(
      workbookActiveSheetId(
        {
          workbook: {
            bookViews: { workbookView: { activeTab: "1" } }
          }
        },
        [
          { id: "sheet-1" },
          { id: "sheet-7" }
        ]
      )
    ).toBe("sheet-7");
  });

  it("detects the XLSX 1904 date system flag from workbook properties", () => {
    expect(workbookUsesDate1904({ workbook: { workbookPr: { date1904: "1" } } })).toBe(true);
    expect(workbookUsesDate1904({ workbook: { workbookPr: { date1904: "true" } } })).toBe(true);
    expect(workbookUsesDate1904({ workbook: { workbookPr: { date1904: "0" } } })).toBe(false);
  });

  it("converts imported XLSX 1904 date serials to the QExcell 1900 serial system", async () => {
    const zip = new JSZip();
    zip.file(
      "xl/workbook.xml",
      `<workbook><workbookPr date1904="1"/><sheets><sheet name="Dates" sheetId="1" r:id="rId1"/></sheets></workbook>`
    );
    zip.file(
      "xl/_rels/workbook.xml.rels",
      `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Target="worksheets/sheet1.xml"/></Relationships>`
    );
    zip.file("xl/styles.xml", `<styleSheet><cellXfs count="3"><xf numFmtId="0"/><xf numFmtId="14"/><xf numFmtId="20"/></cellXfs></styleSheet>`);
    zip.file(
      "xl/worksheets/sheet1.xml",
      `<worksheet><sheetData><row r="1"><c r="A1" s="1"><v>43465</v></c><c r="B1"><v>5</v></c><c r="C1" s="2"><v>0.5</v></c></row></sheetData></worksheet>`
    );

    const blob = await zip.generateAsync({
      type: "blob",
      mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
    });
    const imported = await importXlsxFile(new File([blob], "Date1904.xlsx", { type: blob.type }));

    expect(imported.sheets[0].cells).toEqual({ A1: "44927", B1: "5", C1: "0.5" });
    expect(imported.sheets[0].cellFormats).toEqual({ A1: { numberFormat: "m/d/yy" }, C1: { numberFormat: "h:mm" } });
  });

  it("сохраняет и импортирует активный лист XLSX через workbookView activeTab", async () => {
    const blob = await exportXlsxBlob({
      id: "book-1",
      title: "Активный лист.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-2",
      sheets: [
        { id: "sheet-1", name: "Первый", cells: { A1: "Первый" } },
        { id: "sheet-2", name: "Второй", cells: { A1: "Второй" } }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const workbookXml = await zip.file("xl/workbook.xml")?.async("string");
    const imported = await importXlsxFile(new File([blob], "Активный лист.xlsx", { type: blob.type }));

    expect(workbookXml).toContain('<workbookView activeTab="1"/>');
    expect(imported.activeSheet).toBe("sheet-2");
  });

  it("normalizes XLSX sheet names to Excel-safe unique names on export", async () => {
    expect(
      xlsxSafeSheetNames([
        { name: "Sales/2026:Q1*?" },
        { name: "'Very long worksheet name that exceeds thirty one characters'" },
        { name: "Sales 2026 Q1" },
        { name: "'[]:*?/\\'" },
        { name: "History" }
      ])
    ).toEqual(["Sales 2026 Q1", "Very long worksheet name that e", "Sales 2026 Q1 (2)", "Лист 4", "History 1"]);

    const blob = await exportXlsxBlob({
      id: "book-1",
      title: "Safe sheet names.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        { id: "sheet-1", name: "Sales/2026:Q1*?", printArea: "A1:B2", cells: { A1: "Sales" } },
        { id: "sheet-2", name: "Sales 2026 Q1", cells: { A1: "Duplicate" } }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const workbookXml = await zip.file("xl/workbook.xml")?.async("string");
    const imported = await importXlsxFile(new File([blob], "Safe sheet names.xlsx", { type: blob.type }));

    expect(workbookXml).toContain('<sheet name="Sales 2026 Q1" sheetId="1" r:id="rId1"/>');
    expect(workbookXml).toContain('<sheet name="Sales 2026 Q1 (2)" sheetId="2" r:id="rId2"/>');
    expect(workbookXml).toContain('<definedName name="_xlnm.Print_Area" localSheetId="0">\'Sales 2026 Q1\'!$A$1:$B$2</definedName>');
    expect(imported.sheets.map((sheet) => sheet.name)).toEqual(["Sales 2026 Q1", "Sales 2026 Q1 (2)"]);
    expect(imported.sheets[0].printArea).toBe("A1:B2");
  });

  it("сохраняет и импортирует область печати XLSX через definedName _xlnm.Print_Area", async () => {
    expect(
      workbookPrintAreas(
        {
          workbook: {
            definedNames: {
              definedName: [
                { name: "_xlnm.Print_Area", localSheetId: "0", "#text": "'Отчет'!$D$20:$A$1" },
                { name: "_xlnm.Print_Area", localSheetId: "1", "#text": "'Архив'!$B$2:$C$4,'Архив'!$E$1:$E$3" }
              ]
            }
          }
        },
        [
          { id: "sheet-1", name: "Отчет" },
          { id: "sheet-2", name: "Архив" }
        ]
      )
    ).toEqual({ "sheet-1": "A1:D20", "sheet-2": "B2:C4,E1:E3" });

    const blob = await exportXlsxBlob({
      id: "book-1",
      title: "Область печати.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        { id: "sheet-1", name: "Отчет", printArea: "D20:A1", cells: { A1: "Начало", D20: "Итог" } },
        { id: "sheet-2", name: "Архив", printArea: "B2:C4,E1:E3", cells: { B2: "Архив" } }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const workbookXml = await zip.file("xl/workbook.xml")?.async("string");
    const imported = await importXlsxFile(new File([blob], "Область печати.xlsx", { type: blob.type }));

    expect(workbookXml).toContain('<definedNames><definedName name="_xlnm.Print_Area" localSheetId="0">\'Отчет\'!$A$1:$D$20</definedName>');
    expect(workbookXml).toContain('<definedName name="_xlnm.Print_Area" localSheetId="1">\'Архив\'!$B$2:$C$4,\'Архив\'!$E$1:$E$3</definedName></definedNames>');
    expect(imported.sheets[0].printArea).toBe("A1:D20");
    expect(imported.sheets[1].printArea).toBe("B2:C4,E1:E3");
  });

  it("сохраняет и импортирует скрытые листы XLSX через sheet state", async () => {
    const blob = await exportXlsxBlob({
      id: "book-1",
      title: "Скрытые листы.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        { id: "sheet-1", name: "Рабочий", cells: { A1: "Открыт" } },
        { id: "sheet-2", name: "Архив", visibility: "hidden", cells: { A1: "Скрыт" } },
        { id: "sheet-3", name: "Служебный", visibility: "veryHidden", cells: { A1: "Очень скрыт" } }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const workbookXml = await zip.file("xl/workbook.xml")?.async("string");
    const imported = await importXlsxFile(new File([blob], "Скрытые листы.xlsx", { type: blob.type }));

    expect(workbookXml).toContain('<sheet name="Архив" sheetId="2" r:id="rId2" state="hidden"/>');
    expect(workbookXml).toContain('<sheet name="Служебный" sheetId="3" r:id="rId3" state="veryHidden"/>');
    expect(imported.sheets[1]).toMatchObject({ id: "sheet-2", name: "Архив", visibility: "hidden" });
    expect(imported.sheets[2]).toMatchObject({ id: "sheet-3", name: "Служебный", visibility: "veryHidden" });
  });

  it("читает и записывает закрепленные области XLSX через sheetViews pane", async () => {
    expect(
      worksheetXmlToFrozenPane({
        worksheet: {
          sheetViews: {
            sheetView: {
              pane: { xSplit: "1", ySplit: "2", topLeftCell: "B3", activePane: "bottomRight", state: "frozen" }
            }
          }
        }
      })
    ).toEqual({ columns: 1, rows: 2, topLeftCell: "B3", activePane: "bottomRight" });

    expect(
      worksheetXmlToFrozenPane({
        worksheet: {
          sheetViews: {
            sheetView: {
              pane: { xSplit: "1", state: "split" }
            }
          }
        }
      })
    ).toBeUndefined();

    expect(buildSheetViewsXml({ columns: 1, rows: 1 })).toBe(
      '<sheetViews><sheetView workbookViewId="0"><pane xSplit="1" ySplit="1" topLeftCell="B2" activePane="bottomRight" state="frozen"/></sheetView></sheetViews>'
    );

    const blob = await exportXlsxBlob({
      id: "book-1",
      title: "Frozen panes.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Freeze",
          frozenPane: { columns: 1, rows: 1 },
          cells: { A1: "Header", B2: "Body" }
        }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const sheetXml = (await zip.file("xl/worksheets/sheet1.xml")?.async("string")) ?? "";
    const imported = await importXlsxFile(new File([blob], "Frozen panes.xlsx", { type: blob.type }));

    expect(sheetXml).toContain(
      '<sheetViews><sheetView workbookViewId="0"><pane xSplit="1" ySplit="1" topLeftCell="B2" activePane="bottomRight" state="frozen"/></sheetView></sheetViews>'
    );
    expect(sheetXml.indexOf("<sheetViews>")).toBeLessThan(sheetXml.indexOf("<sheetData>"));
    expect(imported.sheets[0].frozenPane).toEqual({ columns: 1, rows: 1, topLeftCell: "B2", activePane: "bottomRight" });
  });

  it("читает и записывает скрытие сетки листа XLSX через sheetView showGridLines", async () => {
    expect(
      worksheetXmlToShowGridLines({
        worksheet: {
          sheetViews: {
            sheetView: { showGridLines: "0" }
          }
        }
      })
    ).toBe(false);
    expect(buildSheetViewsXml(undefined, false)).toBe('<sheetViews><sheetView workbookViewId="0" showGridLines="0"/></sheetViews>');
    expect(buildSheetViewsXml({ rows: 1 }, false)).toBe(
      '<sheetViews><sheetView workbookViewId="0" showGridLines="0"><pane ySplit="1" topLeftCell="A2" activePane="bottomLeft" state="frozen"/></sheetView></sheetViews>'
    );

    const blob = await exportXlsxBlob({
      id: "book-1",
      title: "Grid lines.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Grid",
          showGridLines: false,
          cells: { A1: "No grid" }
        }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const sheetXml = (await zip.file("xl/worksheets/sheet1.xml")?.async("string")) ?? "";
    const imported = await importXlsxFile(new File([blob], "Grid lines.xlsx", { type: blob.type }));

    expect(sheetXml).toContain('<sheetViews><sheetView workbookViewId="0" showGridLines="0"/></sheetViews>');
    expect(imported.sheets[0].showGridLines).toBe(false);
  });

  it("читает и записывает масштаб листа XLSX через sheetView zoomScale", async () => {
    expect(
      worksheetXmlToZoomScale({
        worksheet: {
          sheetViews: {
            sheetView: { zoomScale: "125" }
          }
        }
      })
    ).toBe(125);
    expect(
      worksheetXmlToZoomScale({
        worksheet: {
          sheetViews: {
            sheetView: { zoomScale: "100" }
          }
        }
      })
    ).toBe(0);
    expect(buildSheetViewsXml(undefined, undefined, 125)).toBe('<sheetViews><sheetView workbookViewId="0" zoomScale="125"/></sheetViews>');
    expect(buildSheetViewsXml({ columns: 1 }, false, 90)).toBe(
      '<sheetViews><sheetView workbookViewId="0" showGridLines="0" zoomScale="90"><pane xSplit="1" topLeftCell="B1" activePane="topRight" state="frozen"/></sheetView></sheetViews>'
    );

    const blob = await exportXlsxBlob({
      id: "book-1",
      title: "Zoom.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Zoom",
          zoomScale: 125,
          cells: { A1: "Zoomed" }
        }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const sheetXml = (await zip.file("xl/worksheets/sheet1.xml")?.async("string")) ?? "";
    const imported = await importXlsxFile(new File([blob], "Zoom.xlsx", { type: blob.type }));

    expect(sheetXml).toContain('<sheetViews><sheetView workbookViewId="0" zoomScale="125"/></sheetViews>');
    expect(imported.sheets[0].zoomScale).toBe(125);
  });

  it("читает и записывает автофильтр XLSX через autoFilter ref", async () => {
    expect(
      worksheetXmlToAutoFilter({
        worksheet: {
          autoFilter: { ref: "$D$20:$A$1" }
        }
      })
    ).toBe("A1:D20");
    expect(buildAutoFilterXml("B2:B2")).toBe('<autoFilter ref="B2"/>');
    expect(buildAutoFilterXml("bad")).toBe("");

    const blob = await exportXlsxBlob({
      id: "book-1",
      title: "AutoFilter.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Filter",
          autoFilter: "D20:A1",
          mergedCells: [{ start: "A22", end: "D22" }],
          cells: { A1: "Product", D20: "Total" }
        }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const sheetXml = (await zip.file("xl/worksheets/sheet1.xml")?.async("string")) ?? "";
    const imported = await importXlsxFile(new File([blob], "AutoFilter.xlsx", { type: blob.type }));

    expect(sheetXml).toContain('<autoFilter ref="A1:D20"/>');
    expect(sheetXml.indexOf("<sheetData>")).toBeLessThan(sheetXml.indexOf("<autoFilter"));
    expect(sheetXml.indexOf("<autoFilter")).toBeLessThan(sheetXml.indexOf("<mergeCells"));
    expect(imported.sheets[0].autoFilter).toBe("A1:D20");
  });

  it("читает и записывает цвет вкладки листа XLSX через sheetPr tabColor", async () => {
    expect(
      worksheetXmlToTabColor({
        worksheet: {
          sheetPr: { tabColor: { rgb: "FF0F766E" } }
        }
      })
    ).toBe("0F766E");
    expect(
      worksheetXmlToTabColor(
        {
          worksheet: {
            sheetPr: { tabColor: { theme: "4" } }
          }
        },
        ["000000", "FFFFFF", "1F497D", "EEECE1", "123456"]
      )
    ).toBe("123456");
    expect(buildSheetPrXml("#0f766e")).toBe('<sheetPr><tabColor rgb="FF0F766E"/></sheetPr>');
    expect(buildSheetPrXml("bad")).toBe("");

    const blob = await exportXlsxBlob({
      id: "book-1",
      title: "Tab color.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Color",
          tabColor: "#0f766e",
          frozenPane: { rows: 1 },
          cells: { A1: "Header" }
        }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const sheetXml = (await zip.file("xl/worksheets/sheet1.xml")?.async("string")) ?? "";
    const imported = await importXlsxFile(new File([blob], "Tab color.xlsx", { type: blob.type }));

    expect(sheetXml).toContain('<sheetPr><tabColor rgb="FF0F766E"/></sheetPr>');
    expect(sheetXml.indexOf("<sheetPr>")).toBeLessThan(sheetXml.indexOf("<sheetViews>"));
    expect(imported.sheets[0].tabColor).toBe("0F766E");
  });

  it("читает и записывает размеры колонок и строк XLSX", async () => {
    expect(
      worksheetXmlToColumnWidths({
        worksheet: {
          cols: {
            col: [
              { min: "1", max: "2", width: "18.5" },
              { min: "4", max: "4", width: "9.25" }
            ]
          }
        }
      })
    ).toEqual({ A: 18.5, B: 18.5, D: 9.25 });
    expect(
      worksheetXmlToRowHeights({
        worksheet: {
          sheetData: {
            row: [{ r: "1", ht: "24" }, { r: "4", ht: "30.5" }]
          }
        }
      })
    ).toEqual({ "1": 24, "4": 30.5 });
    expect(buildColumnWidthsXml({ C: 9.25, A: 18.5, "1bad": 1 })).toBe(
      '<cols><col min="1" max="1" width="18.5" customWidth="1"/><col min="3" max="3" width="9.25" customWidth="1"/></cols>'
    );

    const blob = await exportXlsxBlob({
      id: "book-1",
      title: "Sheet sizes.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Sizes",
          columnWidths: { A: 18.5, C: 9.25 },
          rowHeights: { "1": 24, "4": 30.5 },
          cells: { A1: "Header", C2: "Value" }
        }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const sheetXml = (await zip.file("xl/worksheets/sheet1.xml")?.async("string")) ?? "";
    const imported = await importXlsxFile(new File([blob], "Sheet sizes.xlsx", { type: blob.type }));

    expect(sheetXml).toContain(
      '<cols><col min="1" max="1" width="18.5" customWidth="1"/><col min="3" max="3" width="9.25" customWidth="1"/></cols>'
    );
    expect(sheetXml).toContain('<row r="1" ht="24" customHeight="1"><c r="A1" t="inlineStr"><is><t>Header</t></is></c></row>');
    expect(sheetXml).toContain('<row r="4" ht="30.5" customHeight="1"/>');
    expect(sheetXml.indexOf("<cols>")).toBeLessThan(sheetXml.indexOf("<sheetData>"));
    expect(imported.sheets[0].columnWidths).toEqual({ A: 18.5, C: 9.25 });
    expect(imported.sheets[0].rowHeights).toEqual({ "1": 24, "4": 30.5 });
  });

  it("читает и записывает скрытые колонки и строки XLSX", async () => {
    expect(
      worksheetXmlToHiddenColumns({
        worksheet: {
          cols: {
            col: [
              { min: "2", max: "3", hidden: "1" },
              { min: "5", max: "5", width: "12", hidden: "true" }
            ]
          }
        }
      })
    ).toEqual({ B: true, C: true, E: true });
    expect(
      worksheetXmlToHiddenRows({
        worksheet: {
          sheetData: {
            row: [{ r: "4", hidden: "1" }, { r: "6", ht: "21", hidden: "true" }]
          }
        }
      })
    ).toEqual({ "4": true, "6": true });
    expect(buildColumnWidthsXml({ E: 12 }, { B: true, C: true, E: true })).toBe(
      '<cols><col min="2" max="2" hidden="1"/><col min="3" max="3" hidden="1"/><col min="5" max="5" width="12" customWidth="1" hidden="1"/></cols>'
    );

    const blob = await exportXlsxBlob({
      id: "book-1",
      title: "Hidden rows and columns.xlsx",
      updatedAt: "2026-06-01T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Hidden",
          columnWidths: { E: 12 },
          rowHeights: { "6": 21 },
          hiddenColumns: { B: true, C: true, E: true },
          hiddenRows: { "4": true, "6": true },
          cells: { A1: "Visible" }
        }
      ]
    });
    const zip = await JSZip.loadAsync(await blob.arrayBuffer());
    const sheetXml = (await zip.file("xl/worksheets/sheet1.xml")?.async("string")) ?? "";
    const imported = await importXlsxFile(new File([blob], "Hidden rows and columns.xlsx", { type: blob.type }));

    expect(sheetXml).toContain(
      '<cols><col min="2" max="2" hidden="1"/><col min="3" max="3" hidden="1"/><col min="5" max="5" width="12" customWidth="1" hidden="1"/></cols>'
    );
    expect(sheetXml).toContain('<row r="4" hidden="1"/>');
    expect(sheetXml).toContain('<row r="6" ht="21" customHeight="1" hidden="1"/>');
    expect(imported.sheets[0].hiddenColumns).toEqual({ B: true, C: true, E: true });
    expect(imported.sheets[0].hiddenRows).toEqual({ "4": true, "6": true });
  });

  it("создает OOXML chart part для диаграммы XLSX", () => {
    const xml = buildChartXml(
      {
        id: "chart-1",
        type: "bar",
        title: "Итого",
        labelRange: "A2:A4",
        valueRange: "E2:E4"
      },
      "Бюджет",
      {
        A2: "Базовый",
        A3: "Команды",
        A4: "Корпоративный",
        E2: "43600",
        E3: "27200",
        E4: "64800"
      }
    );

    expect(xml).toContain("<c:barChart>");
    expect(xml).toContain("<c:f>'Бюджет'!$A$2:$A$4</c:f>");
    expect(xml).toContain("<c:f>'Бюджет'!$E$2:$E$4</c:f>");
    expect(xml).toContain("<c:v>Базовый</c:v>");
    expect(xml).toContain("<c:v>43600</c:v>");
  });

  it("читает базовую диаграмму из chart XML", () => {
    expect(
      chartXmlToSheetChart(
        {
          "c:chartSpace": {
            "c:chart": {
              "c:title": {
                "c:tx": {
                  "c:rich": {
                    "a:p": { "a:r": { "a:t": "Продажи" } }
                  }
                }
              },
              "c:plotArea": {
                "c:lineChart": {
                  "c:ser": {
                    "c:cat": { "c:strRef": { "c:f": "'Бюджет'!$A$2:$A$4" } },
                    "c:val": { "c:numRef": { "c:f": "'Бюджет'!$E$2:$E$4" } }
                  }
                }
              }
            }
          }
        },
        "Бюджет",
        0
      )
    ).toEqual({
      id: "xlsx-chart-1",
      type: "line",
      title: "Продажи",
      labelRange: "A2:A4",
      valueRange: "E2:E4"
    });
  });

  it("готовит точки диаграммы из диапазонов листа", () => {
    expect(
      chartDataPoints(
        {
          id: "chart-1",
          type: "bar",
          title: "Итого",
          labelRange: "A2:A3",
          valueRange: "E2:E3"
        },
        { A2: "Базовый", A3: "Команды", E2: "=SUM(B2:D2)", B2: "10", C2: "20", D2: "30", E3: "25" }
      )
    ).toEqual([
      { label: "Базовый", value: 60 },
      { label: "Команды", value: 25 }
    ]);
  });

  it("сохраняет и импортирует несколько листов с дальними ячейками", async () => {
    const blob = await exportXlsxBlob({
      id: "workbook",
      title: "Бюджет.xlsx",
      updatedAt: "2026-05-31T00:00:00.000Z",
      activeSheet: "sheet-1",
      sheets: [
        {
          id: "sheet-1",
          name: "Бюджет",
          cells: {
            A1: "Статья",
            AA20: "7",
            AB20: "8",
            AC20: "=SUM(AA20:AB20)",
            D20: "44927",
            E20: "0.25"
          },
          mergedCells: [{ start: "A1", end: "C1" }],
          hyperlinks: { A1: "https://example.com/budget" },
          cellFormats: {
            A1: { bold: true, strike: true, fontSize: 14, fontFamily: "Arial", textColor: "0F5FAE", fillColor: "FFF2CC", horizontalAlign: "center", verticalAlign: "middle", wrapText: true, border: true, borderColor: "C2410C" },
            AC20: { underline: true },
            D20: { numberFormat: "dd.mm.yyyy" },
            E20: { numberFormat: "0%" }
          },
          charts: [
            {
              id: "chart-budget",
              type: "bar",
              title: "Итого",
              labelRange: "A2:A3",
              valueRange: "AA20:AB20"
            }
          ]
        },
        {
          id: "sheet-2",
          name: "Справочник",
          cells: {
            B2: "Проект"
          }
        }
      ]
    });

    const imported = await importXlsxFile(new File([blob], "Бюджет.xlsx", { type: blob.type }));

    expect(imported.title).toBe("Бюджет.xlsx");
    expect(imported.sheets).toHaveLength(2);
    expect(imported.sheets[0].name).toBe("Бюджет");
    expect(imported.sheets[0].cells.AC20).toBe("=SUM(AA20:AB20)");
    expect(imported.sheets[0].mergedCells).toEqual([{ start: "A1", end: "C1" }]);
    expect(imported.sheets[0].hyperlinks).toEqual({ A1: "https://example.com/budget" });
    expect(imported.sheets[0].cellFormats).toEqual({
      A1: { bold: true, strike: true, fontSize: 14, fontFamily: "Arial", textColor: "0F5FAE", fillColor: "FFF2CC", horizontalAlign: "center", verticalAlign: "middle", wrapText: true, border: true, borderColor: "C2410C" },
      AC20: { underline: true },
      D20: { numberFormat: "dd.mm.yyyy" },
      E20: { numberFormat: "0%" }
    });
    expect(imported.sheets[0].charts).toEqual([
      {
        id: "xlsx-chart-1",
        type: "bar",
        title: "Итого",
        labelRange: "A2:A3",
        valueRange: "AA20:AB20"
      }
    ]);
    expect(imported.sheets[1].name).toBe("Справочник");
    expect(imported.sheets[1].cells.B2).toBe("Проект");
  });
});