/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */

/* libwps

 * Version: MPL 2.0 / LGPLv2.1+

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * Major Contributor(s):

 * Copyright (C) 2006, 2007 Andrew Ziem

 * Copyright (C) 2004 Marc Maurer (uwog@uwog.net)

 * Copyright (C) 2004-2006 Fridrich Strba (fridrich.strba@bluewin.ch)

 *

 * For minor contributions see the git repository.

 *

 * Alternatively, the contents of this file may be used under the terms

 * of the GNU Lesser General Public License Version 2.1 or later

 * (LGPLv2.1+), in which case the provisions of the LGPLv2.1+ are

 * applicable instead of those above.

 */

#include <stdlib.h>

#include <string.h>

#include <algorithm>

#include <cmath>

#include <sstream>

#include <stack>

#include <utility>

#include <librevenge-stream/librevenge-stream.h>

#include "libwps_internal.h"

#include "libwps_tools_win.h"

#include "WKSContentListener.h"

#include "WKSSubDocument.h"

#include "WPSCell.h"

#include "WPSEntry.h"

#include "WPSFont.h"

#include "WPSHeader.h"

#include "WPSOLEParser.h"

#include "WPSOLEStream.h"

#include "WPSPageSpan.h"

#include "WPSStream.h"

#include "WPSStringStream.h"

//#include "QuattroChart.h"

#include "QuattroFormula.h"

#include "QuattroGraph.h"

#include "QuattroSpreadsheet.h"

#include "Quattro.h"

using namespace libwps;

//! Internal: namespace to define internal class of QuattroParser

namespace QuattroParserInternal

{

//! the font of a QuattroParser

struct Font final : public WPSFont

{

  //! constructor

  explicit Font(libwps_tools_win::Font::Type type) : WPSFont(), m_type(type)

  {

  }

  Font(Font const &)=default;

  //! destructor

  ~Font() final;

  //! font encoding type

  libwps_tools_win::Font::Type m_type;

};

Font::~Font()

{

}

//! Internal: the subdocument of a WPS4Parser

class SubDocument final : public WKSSubDocument

{

public:

  //! constructor for a text entry

  SubDocument(RVNGInputStreamPtr const &input, QuattroParser &pars, bool header) :

    WKSSubDocument(input, &pars), m_header(header) {}

  //! destructor

  ~SubDocument() final {}

  //! operator==

  bool operator==(std::shared_ptr<WPSSubDocument> const &doc) const final

  {

    if (!doc || !WKSSubDocument::operator==(doc))

      return false;

    auto const *sDoc = dynamic_cast<SubDocument const *>(doc.get());

    if (!sDoc) return false;

    return m_header == sDoc->m_header;

  }

  //! the parser function

  void parse(std::shared_ptr<WKSContentListener> &listener, libwps::SubDocumentType subDocumentType) final;

  //! a flag to known if we need to send the header or the footer

  bool m_header;

};

void SubDocument::parse(std::shared_ptr<WKSContentListener> &listener, libwps::SubDocumentType)

{

  if (!listener.get())

  {

    WPS_DEBUG_MSG(("QuattroParserInternal::SubDocument::parse: no listener\n"));

    return;

  }

  if (!dynamic_cast<WKSContentListener *>(listener.get()))

  {

    WPS_DEBUG_MSG(("QuattroParserInternal::SubDocument::parse: bad listener\n"));

    return;

  }

  QuattroParser *pser = m_parser ? dynamic_cast<QuattroParser *>(m_parser) : nullptr;

  if (!pser)

  {

    listener->insertCharacter(' ');

    WPS_DEBUG_MSG(("QuattroParserInternal::SubDocument::parse: bad parser\n"));

    return;

  }

  pser->sendHeaderFooter(m_header);

}

//! a zone name

struct ZoneName

{

  //! constructor

  explicit ZoneName(char const *name, char const *extra=nullptr)

    : m_name(name)

    , m_extra(extra==nullptr ? "" : extra)

  {

  }

  //! the zone name

  std::string m_name;

  //! the extra data

  std::string m_extra;

};

//! the state of QuattroParser

struct State

{

  //! constructor

  explicit State(libwps_tools_win::Font::Type fontType, char const *password)

    : m_fontType(fontType)

    , m_version(-1)

    , m_metaData()

    , m_actualSheet(-1)

    , m_fontsList()

    , m_colorsList()

    , m_idToExternalFileMap()

    , m_idToExternalNameMap()

    , m_idToFieldMap()

    , m_pageSpan()

    , m_actPage(0)

    , m_numPages(0)

    , m_headerString()

    , m_footerString()

    , m_password(password)

    , m_isEncrypted(false)

    , m_isDecoded(false)

    , m_idToZoneNameMap()

    , m_readingZone341(false)

  {

  }

  //! return the default font style

  libwps_tools_win::Font::Type getDefaultFontType() const

  {

    if (m_fontType != libwps_tools_win::Font::UNKNOWN)

      return m_fontType;

    return libwps_tools_win::Font::WIN3_WEUROPE;

  }

  //! returns a color corresponding to an id

  bool getColor(int id, WPSColor &color) const;

  //! returns a default font (Courier12) with file's version to define the default encoding */

  static WPSFont getDefaultFont()

  {

    WPSFont res;

    res.m_name="Times New Roman";

    res.m_size=12;

    return res;

  }

  //! init the zone name map

  void initZoneNameMap();

  //! the user font type

  libwps_tools_win::Font::Type m_fontType;

  //! the file version

  int m_version;

  //! the meta data

  librevenge::RVNGPropertyList m_metaData;

  //! the actual sheet

  int m_actualSheet;

  //! the font list

  std::vector<Font> m_fontsList;

  //! the color list

  std::vector<WPSColor> m_colorsList;

  //! map id to filename

  std::map<int, librevenge::RVNGString> m_idToExternalFileMap;

  //! map id to external name

  std::map<int, librevenge::RVNGString> m_idToExternalNameMap;

  //! map id to field

  std::map<int, std::pair<librevenge::RVNGString, QuattroFormulaInternal::CellReference> >m_idToFieldMap;

  //! the actual document size

  WPSPageSpan m_pageSpan;

  int m_actPage /** the actual page*/, m_numPages /* the number of pages */;

  //! the header string

  librevenge::RVNGString m_headerString;

  //! the footer string

  librevenge::RVNGString m_footerString;

  //! the password (if known)

  char const *m_password;

  //! true if the file is encrypted

  bool m_isEncrypted;

  //! true if the main stream has been decoded

  bool m_isDecoded;

  //! map zone id to zone name

  std::map<int, ZoneName> m_idToZoneNameMap;

  //! true if zone 341 is being read. Avoids recursion.

  bool m_readingZone341;

private:

  State(State const &)=delete;

  State &operator=(State const &)=delete;

};

bool State::getColor(int id, WPSColor &color) const

{

  if (m_colorsList.empty())

  {

    auto *THIS=const_cast<State *>(this);

    static const uint32_t quattroColorMap[]=

    {

      0xFFFFFF, 0xC0C0C0, 0x808080, 0x000000,

      0xFF0000, 0x00FF00, 0x0000FF, 0x00FFFF,

      0xFF00FF, 0xFFFF00, 0x800080, 0x000080,

      0x808000, 0x008000, 0x800000, 0x008080

    };

    for (uint32_t i : quattroColorMap)

      THIS->m_colorsList.push_back(WPSColor(i));

  }

  if (id < 0 || id >= int(m_colorsList.size()))

  {

    WPS_DEBUG_MSG(("QuattroParserInternal::State::getColor(): unknown Quattro Pro color id: %d\n",id));

    return false;

  }

  color = m_colorsList[size_t(id)];

  return true;

}

void State::initZoneNameMap()

{

  if (!m_idToZoneNameMap.empty())

    return;

  m_idToZoneNameMap=std::map<int, ZoneName>

  {

    { 0x0, ZoneName("File", "begin") },

    { 0x1, ZoneName("File", "end") },

    { 0x2, ZoneName("Recalculation", "mode") },

    { 0x3, ZoneName("Recalculation", "order") },

    { 0x6, ZoneName("Sheet", "size") },

    { 0xb, ZoneName("FldName") },

    { 0xc, ZoneName("Cell", "blank") },

    { 0xd, ZoneName("Cell", "int") },

    { 0xe, ZoneName("Cell", "float") },

    { 0xf, ZoneName("Cell", "label") },

    { 0x10, ZoneName("Cell", "formula") },

    { 0x18, ZoneName("Range", "table") },

    { 0x19, ZoneName("Range", "query") },

    { 0x1a, ZoneName("Print", "block") },

    { 0x1b, ZoneName("Range", "sort,block") },

    { 0x1c, ZoneName("Range", "fill") },

    { 0x1d, ZoneName("Range", "sort,firstKey") },

    { 0x20, ZoneName("Range", "frequency") },

    { 0x23, ZoneName("Range", "sort,secondKey") },

    { 0x24, ZoneName("Protection") },

    { 0x25, ZoneName("Print", "footer") },

    { 0x26, ZoneName("Print", "header") },

    { 0x27, ZoneName("Print", "setup") },

    { 0x28, ZoneName("Print", "margins") },

    { 0x2f, ZoneName("Recalculation", "iteration,count") },

    { 0x30, ZoneName("Print", "pagebreak") },

    { 0x33, ZoneName("Cell", "string,value") },

    { 0x4b, ZoneName("Password", "data") },

    { 0x4c, ZoneName("Password", "level") },

    { 0x4d, ZoneName("System", "property") },

    { 0x66, ZoneName("Range", "parse") },

    { 0x67, ZoneName("Range", "regression") },

    { 0x69, ZoneName("Range", "matrix") },

    { 0x96, ZoneName("Column", "size") },

    { 0x97, ZoneName("External", "link") },

    { 0x98, ZoneName("External", "name") },

    { 0x99, ZoneName("Macro", "library") },

    // 0x9d Cell style (never seen)

    // 0x9e Conditional border color (never seen)

    { 0x9f, ZoneName("Range", "sort,thirdKey") },

    { 0xa0, ZoneName("Range", "sort,fourstKey") },

    { 0xa1, ZoneName("Range", "sort,fifthKey") },

    { 0xb7, ZoneName("Range", "solve for") },

    { 0xc9, ZoneName("Version") },

    { 0xca, ZoneName("Sheet", "begin") },

    { 0xcb, ZoneName("Sheet", "end") },

    { 0xcc, ZoneName("Sheet", "name") },

    { 0xce, ZoneName("Cell", "style") },

    { 0xcf, ZoneName("FontDef") },

    { 0xd0, ZoneName("StyleName") },

    { 0xd1, ZoneName("Sheet", "attribute") },

    { 0xd2, ZoneName("Pane", "row,default") },

    { 0xd3, ZoneName("Pane", "row2,default") },

    { 0xd4, ZoneName("Pane", "col,default") },

    { 0xd5, ZoneName("Pane", "col2,default") },

    { 0xd6, ZoneName("Pane", "row") },

    { 0xd7, ZoneName("Pane", "row2") },

    { 0xd8, ZoneName("Pane", "col") },

    { 0xd9, ZoneName("Pane", "col2") },

    { 0xda, ZoneName("Pane", "font,max") },

    { 0xdb, ZoneName("Pane", "font2,max") },

    { 0xdc, ZoneName("Pane", "row,hidden") },

    { 0xdd, ZoneName("Pane", "row2,hidden") },

    { 0xde, ZoneName("Pane", "col,hidden") },

    { 0xdf, ZoneName("Pane", "col2,hidden") },

    { 0xe0, ZoneName("Pane", "style") },

    { 0xe1, ZoneName("Pane", "style2") },

    { 0xe2, ZoneName("PageGroup", "on") },

    { 0xe3, ZoneName("PageGroup") },

    { 0xe4, ZoneName("DLLIdFunct", "e5") },

    { 0xe5, ZoneName("DLLIdFunct", "e6") },

    { 0xe6, ZoneName("UserFormat") },

    { 0xe7, ZoneName("Column", "def,attr") },

    { 0xe8, ZoneName("ColorList") },

    { 0xe9, ZoneName("Collection") }, // list of cell reference data, never seens

    { 0xed, ZoneName("Print", "beg,names") },

    { 0xee, ZoneName("Print", "formula") },

    { 0xef, ZoneName("Print", "block,delimiter") },

    { 0xf0, ZoneName("Print", "page,delimiter") },

    { 0xf1, ZoneName("Print", "copies") },

    { 0xf2, ZoneName("Print", "pages") },

    { 0xf3, ZoneName("Print", "density") },

    { 0xf4, ZoneName("Print", "tofit") },

    { 0xf5, ZoneName("Print", "scaling") },

    { 0xf6, ZoneName("Print", "paper,type") },

    { 0xf7, ZoneName("Print", "orientation") },

    { 0xf8, ZoneName("Print", "left,border") },

    { 0xf9, ZoneName("Print", "top,border") },

    { 0xfa, ZoneName("Print", "center,blocks") },

    { 0xfb, ZoneName("Print", "end") },

    { 0xfc, ZoneName("Print", "header,font") },

    { 0x101, ZoneName("Print", "headings") },

    { 0x102, ZoneName("Print", "gridlines") },

    { 0x103, ZoneName("Optimizer") },

    { 0x104, ZoneName("Optimizer", "constraint") },

    { 0x105, ZoneName("Pane", "row,range") },

    { 0x106, ZoneName("Pane", "row2,range") },

    { 0x107, ZoneName("Pane", "font,max,range") },

    { 0x108, ZoneName("Pane", "font2,max,range") },

    { 0x109, ZoneName("Print", "beg,record") },

    { 0x10a, ZoneName("Print", "beg,graph") },

    { 0x10c, ZoneName("Print", "draft,margins") },

    { 0x10d, ZoneName("Show", "compatible") },

    { 0x110, ZoneName("Print", "footer,font") },

    { 0x111, ZoneName("Print", "area") },

    { 0x12e, ZoneName("Object", "number") },

    { 0x12f, ZoneName("Query", "table,command") },

    { 0x132, ZoneName("Formula", "compile") },

    { 0x133, ZoneName("Formula", "audit") },

    { 0x134, ZoneName("Sheet", "tab,color") },

    { 0x135, ZoneName("Sheet", "zoom") },

    { 0x136, ZoneName("Show", "notebook,object") },

    { 0x137, ZoneName("Sheet", "protection") },

    { 0x154, ZoneName("UserFormat", "complete") },

    { 0x191, ZoneName("View", "begin") },

    { 0x192, ZoneName("View", "end") },

    { 0x193, ZoneName("View", "window") },

    { 0x194, ZoneName("View", "location") },

    { 0x195, ZoneName("View", "split") },

    { 0x196, ZoneName("View", "synchronize") },

    { 0x197, ZoneName("View", "pane,info") },

    { 0x198, ZoneName("View", "pane2,info") },

    { 0x199, ZoneName("View", "page") },

    { 0x19a, ZoneName("View", "page2") },

    { 0x19b, ZoneName("View", "current") },

    { 0x19c, ZoneName("View", "display,settings") },

    { 0x19e, ZoneName("View", "zoom") },

    { 0x259, ZoneName("Graph", "begin,name") },

    { 0x25a, ZoneName("Graph", "end") },

    { 0x25d, ZoneName("Graph", "icon,coord") },

    { 0x25e, ZoneName("Slide", "begin") },

    { 0x25f, ZoneName("Slide", "end") },

    { 0x260, ZoneName("Slide", "icon,coord") },

    { 0x262, ZoneName("Slide", "time") },

    { 0x263, ZoneName("Slide", "effect0") },

    { 0x264, ZoneName("Graph", "version") },

    { 0x265, ZoneName("Slide", "speed") },

    { 0x266, ZoneName("Slide", "effect1") },

    { 0x267, ZoneName("Slide", "level") },

    { 0x26a, ZoneName("Slide", "type") },

    { 0x26b, ZoneName("Slide", "comment") },

    { 0x26c, ZoneName("Slide", "master,name") },

    { 0x2bc, ZoneName("Graph", "beg,record") },

    { 0x2bd, ZoneName("Chart", "beg,serie") },

    { 0x2be, ZoneName("Chart", "end,serie") },

    { 0x2bf, ZoneName("Serie", "Xlabel") },

    { 0x2c0, ZoneName("Serie", "Zlabel") },

    { 0x2c1, ZoneName("Serie", "legend") },

    { 0x2c2, ZoneName("Serie", "number") },

    { 0x2c3, ZoneName("Serie", "beg,data") },

    { 0x2c4, ZoneName("Serie", "end,data") },

    { 0x2c6, ZoneName("Serie", "data") },

    { 0x2c7, ZoneName("Serie", "label") },

    { 0x2c8, ZoneName("Serie", "legend") },

    { 0x2c9, ZoneName("Chart", "beg,record") },

    { 0x2ca, ZoneName("Chart", "end,record") },

    { 0x2cb, ZoneName("Graph", "extension") },

    { 0x2cd, ZoneName("Chart", "beg,save") },

    { 0x2ce, ZoneName("Chart", "end,save") },

    { 0x2db, ZoneName("Graph", "display,order") },

    { 0x2dc, ZoneName("Serie", "extension") },

    { 0x31f, ZoneName("Graph", "end,record") },

    { 0x321, ZoneName("Object", "begin") },

    { 0x322, ZoneName("Object", "end") },

    { 0x335, ZoneName("GrDialog","textbox")},

    { 0x337, ZoneName("GrDialog","37")},

    { 0x33e, ZoneName("GrRect", "circle")},

    { 0x33f, ZoneName("GrDialog","3f")},

    { 0x342, ZoneName("GrDialog","42")},

    { 0x343, ZoneName("GrDialog","button")},

    { 0x345, ZoneName("GrDialog","bitmap")},

    { 0x349, ZoneName("GrDialog","49")},

    { 0x34a, ZoneName("GrDialog","4a")},

    { 0x34e, ZoneName("GrDialog","4e")},

    { 0x34f, ZoneName("GrDialog","4f")},

    { 0x351, ZoneName("GrDialog","51")},

    { 0x35a, ZoneName("GrLine")},

    { 0x35b, ZoneName("GrPolygon")},

    { 0x35c, ZoneName("GrPolygon","line")},

    { 0x35d, ZoneName("GrDialog","5d")},

    { 0x35e, ZoneName("GrDialog","main")},

    { 0x364, ZoneName("GrRect")},

    { 0x36d, ZoneName("GrDialog","6d")},

    { 0x36f, ZoneName("GrTextBox")},

    { 0x379, ZoneName("GrRect", "round")},

    { 0x37b, ZoneName("GrLine", "arrow")},

    { 0x37c, ZoneName("GrPolygon","line,bezier")},

    { 0x381, ZoneName("Object", "frame,ole") },

    { 0x382, ZoneName("Object", "image") },

    { 0x383, ZoneName("Object", "bitmap") },

    { 0x384, ZoneName("Object", "chart") },

    { 0x385, ZoneName("Object", "frame") },

    { 0x386, ZoneName("Object", "button") },

    { 0x388, ZoneName("GrPolygon","bezier")},

    { 0x38b, ZoneName("Object", "ole") },

    { 0x4d3, ZoneName("Object", "shape") }

  };

}

}

// constructor, destructor

QuattroParser::QuattroParser(RVNGInputStreamPtr &input, WPSHeaderPtr &header,

                             libwps_tools_win::Font::Type encoding, char const *password)

  : WKSParser(input, header)

  , m_listener()

  , m_state(new QuattroParserInternal::State(encoding, password))

    //, m_chartParser(new QuattroChart(*this))

  , m_graphParser(new QuattroGraph(*this))

  , m_spreadsheetParser(new QuattroSpreadsheet(*this))

{

}

QuattroParser::~QuattroParser()

{

}

int QuattroParser::version() const

{

  return m_state->m_version;

}

libwps_tools_win::Font::Type QuattroParser::getDefaultFontType() const

{

  return m_state->getDefaultFontType();

}

bool QuattroParser::getExternalFileName(int fId, librevenge::RVNGString &fName) const

{

  auto it = m_state->m_idToExternalFileMap.find(fId);

  if (it!=m_state->m_idToExternalFileMap.end())

  {

    fName=it->second;

    return true;

  }

  WPS_DEBUG_MSG(("QuattroParser::getExternalFileName: can not find %d name\n", fId));

  return false;

}

bool QuattroParser::getField(int fId, librevenge::RVNGString &text,

                             QuattroFormulaInternal::CellReference &ref,

                             librevenge::RVNGString const &fileName) const

{

  ref.m_cells.clear();

  if (fId&0x4000)

  {

    auto it=m_state->m_idToExternalNameMap.find(fId & 0xbfff);

    if (it!=m_state->m_idToExternalNameMap.end() && !it->second.empty())

    {

      text=it->second;

      WKSContentListener::FormulaInstruction instr;

      instr.m_type=instr.F_Text;

      if (!fileName.empty())

      {

        instr.m_content="[";

        instr.m_content+=fileName.cstr();

        instr.m_content+="]";

      }

      instr.m_content+=it->second.cstr();

      ref.addInstruction(instr);

      return true;

    }

    WPS_DEBUG_MSG(("QuattroParser::getField: can not find %d name\n", fId&0xbfff));

    return false;

  }

  auto it = m_state->m_idToFieldMap.find(fId);

  if (it!=m_state->m_idToFieldMap.end())

  {

    text=it->second.first;

    ref=it->second.second;

    if (!fileName.empty())   // unsure

    {

      for (auto &r : ref.m_cells)

      {

        if (r.m_type==r.F_Cell || r.m_type==r.F_CellList)

          r.m_fileName=fileName;

      }

    }

    return true;

  }

  WPS_DEBUG_MSG(("QuattroParser::getField: can not find %d field\n", fId));

  return false;

}

//////////////////////////////////////////////////////////////////////

// interface with QuattroGraph

//////////////////////////////////////////////////////////////////////

bool QuattroParser::sendPageGraphics(int sheetId) const

{

  return m_graphParser->sendPageGraphics(sheetId);

}

bool QuattroParser::sendGraphics(int sheetId, Vec2i const &cell) const

{

  return m_graphParser->sendGraphics(sheetId, cell);

}

//////////////////////////////////////////////////////////////////////

// interface with QuattroSpreadsheet

//////////////////////////////////////////////////////////////////////

Vec2f QuattroParser::getCellPosition(int sheetId, Vec2i const &cell) const

{

  return m_spreadsheetParser->getPosition(sheetId, cell);

}

bool QuattroParser::getColor(int id, WPSColor &color) const

{

  return m_state->getColor(id, color);

}

bool QuattroParser::getFont(int id, WPSFont &font, libwps_tools_win::Font::Type &type) const

{

  if (id < 0 || id>=int(m_state->m_fontsList.size()))

  {

    WPS_DEBUG_MSG(("QuattroParser::getFont: can not find font %d\n", id));

    return false;

  }

  auto const &ft=m_state->m_fontsList[size_t(id)];

  font=ft;

  type=ft.m_type;

  return true;

}

// main function to parse the document

void QuattroParser::parse(librevenge::RVNGSpreadsheetInterface *documentInterface)

{

  RVNGInputStreamPtr input=getInput();

  if (!input)

  {

    WPS_DEBUG_MSG(("QuattroParser::parse: does not find main ole\n"));

    throw (libwps::ParseException());

  }

  if (!checkHeader(nullptr)) throw(libwps::ParseException());

  bool ok=false;

  try

  {

    ascii().setStream(input);

    ascii().open("MN0");

    if (checkHeader(nullptr) && readZones())

      m_listener=createListener(documentInterface);

    if (m_listener)

    {

      //m_chartParser->setListener(m_listener);

      m_graphParser->setListener(m_listener);

      m_spreadsheetParser->setListener(m_listener);

      m_graphParser->updateState();

      m_spreadsheetParser->updateState();

      m_listener->startDocument();

      int numSheet=m_spreadsheetParser->getNumSpreadsheets();

      if (numSheet==0) ++numSheet;

      for (int i=0; i<numSheet; ++i)

        m_spreadsheetParser->sendSpreadsheet(i, m_graphParser->getGraphicCellsInSheet(i));

      m_listener->endDocument();

      m_listener.reset();

      ok = true;

    }

  }

  catch (...)

  {

    WPS_DEBUG_MSG(("QuattroParser::parse: exception catched when parsing MN0\n"));

    throw (libwps::ParseException());

  }

  ascii().reset();

  if (!ok)

    throw(libwps::ParseException());

}

std::shared_ptr<WKSContentListener> QuattroParser::createListener(librevenge::RVNGSpreadsheetInterface *interface)

{

  std::vector<WPSPageSpan> pageList;

  WPSPageSpan ps(m_state->m_pageSpan);

  int numSheet=m_spreadsheetParser->getNumSpreadsheets();

  if (numSheet<=0) numSheet=1;

  if (!m_state->m_headerString.empty())

  {

    WPSSubDocumentPtr subdoc(new QuattroParserInternal::SubDocument

                             (getInput(), *this, true));

    ps.setHeaderFooter(WPSPageSpan::HEADER, WPSPageSpan::ALL, subdoc);

  }

  if (!m_state->m_footerString.empty())

  {

    WPSSubDocumentPtr subdoc(new QuattroParserInternal::SubDocument

                             (getInput(), *this, false));

    ps.setHeaderFooter(WPSPageSpan::FOOTER, WPSPageSpan::ALL, subdoc);

  }

  ps.setPageSpan(numSheet);

  pageList.push_back(ps);

  auto listener=std::make_shared<WKSContentListener>(pageList, interface);

  listener->setMetaData(m_state->m_metaData);

  return listener;

}

////////////////////////////////////////////////////////////

// low level

////////////////////////////////////////////////////////////

// read the header

////////////////////////////////////////////////////////////

bool QuattroParser::checkHeader(WPSHeader *header, bool strict)

{

  m_state.reset(new QuattroParserInternal::State(m_state->m_fontType, m_state->m_password));

  auto input=getInput();

  auto mainStream=std::make_shared<WPSStream>(input, ascii());

  if (!mainStream || !checkHeader(mainStream, strict))

    return false;

  if (header)

  {

    header->setMajorVersion(m_state->m_version);

    header->setCreator(libwps::WPS_QUATTRO_PRO);

    header->setKind(libwps::WPS_SPREADSHEET);

    header->setIsEncrypted(m_state->m_isEncrypted);

    header->setNeedEncoding(true);

  }

  return true;

}

bool QuattroParser::checkHeader(std::shared_ptr<WPSStream> stream, bool strict)

{

  if (!stream)

  {

    WPS_DEBUG_MSG(("QuattroParser::checkHeader: called without stream\n"));

    return false;

  }

  RVNGInputStreamPtr input = stream->m_input;

  libwps::DebugFile &ascFile=stream->m_ascii;

  libwps::DebugStream f;

  if (!input || !stream->checkFilePosition(12))

  {

    WPS_DEBUG_MSG(("QuattroParser::checkHeader: file is too short\n"));

    return false;

  }

  input->seek(0,librevenge::RVNG_SEEK_SET);

  auto firstOffset = int(libwps::readU8(input));

  auto type = int(libwps::read8(input));

  f << "FileHeader:";

  if (firstOffset == 0 && type == 0)

    m_state->m_version=1000;

  else

  {

    WPS_DEBUG_MSG(("QuattroParser::checkHeader: find unexpected first data\n"));

    return false;

  }

  auto val=int(libwps::read16(input));

  if (val==2)

  {

    // version

    val=int(libwps::readU16(input));

    if (val==0x1001)

    {

      m_state->m_version=1001;

      f << "quattropro[wb1],";

    }

    else if (val==0x1002)

    {

      m_state->m_version=1002;

      f << "quattropro[wb2],";

    }

    else if (val==0x1007)

    {

      m_state->m_version=1003;

      f << "quattropro[wb3],";

    }

    else

    {

      WPS_DEBUG_MSG(("QuattroParser::checkHeader: find unknown file version\n"));

      return false;

    }

  }

  else

  {

    WPS_DEBUG_MSG(("QuattroParser::checkHeader: header contain unexpected size field data\n"));

    return false;

  }

  input->seek(0, librevenge::RVNG_SEEK_SET);

  if (strict)

  {

    for (int i=0; i < 6; ++i)

    {

      if (!readZone(stream)) return false;

      if (m_state->m_isEncrypted) break;

    }

  }

  ascFile.addPos(0);

  ascFile.addNote(f.str().c_str());

  return true;

}

bool QuattroParser::readZones()

{

  int const vers=version();

  m_graphParser->cleanState();

  m_spreadsheetParser->cleanState();

  m_state->initZoneNameMap();

  std::shared_ptr<WPSStream> stream(new WPSStream(getInput(), ascii()));

  RVNGInputStreamPtr &input = stream->m_input;

  libwps::DebugFile &ascFile=stream->m_ascii;

  input->seek(0, librevenge::RVNG_SEEK_SET);

  while (true)

  {

    if (!stream->checkFilePosition(input->tell()+4))

      break;

    if (!readZone(stream))

      break;

    if (m_state->m_isEncrypted && !m_state->m_isDecoded)

      throw(libwps::PasswordException());

  }

  //

  // look for ending

  //

  long pos = input->tell();

  if (!stream->checkFilePosition(pos+4))

  {

    WPS_DEBUG_MSG(("QuattroParser::readZones: cell header is too short\n"));

    return m_spreadsheetParser->getNumSpreadsheets()>0;

  }

  auto type = int(libwps::readU16(input)); // 1

  auto length = int(libwps::readU16(input));

  if (length)

  {

    WPS_DEBUG_MSG(("QuattroParser::readZones: parse breaks before ending\n"));

    ascFile.addPos(pos);

    ascFile.addNote("Entries(BAD):###");

    return m_spreadsheetParser->getNumSpreadsheets()>0;

  }

  ascFile.addPos(pos);

  if (type != 1)

  {

    WPS_DEBUG_MSG(("QuattroParser::readZones: odd end cell type: %d\n", type));

    ascFile.addNote("Entries(BAD):###");

    return m_spreadsheetParser->getNumSpreadsheets();

  }

  ascFile.addNote("Entries(EndSpreadsheet)");

  // checkme: crypted .wb3 files also contain an OLE zone, but it seems empty...

  if (vers==1002 || (vers==1003 && m_state->m_isEncrypted))

    readOLEZones(stream);

  if (vers==1003)

  {

    // object in PerfectOffice_OBJECTS/_1507007992_c/, ... *

    parseOLEStream(getFileInput(), "PerfectOffice_MAIN");

  }

  return m_spreadsheetParser->getNumSpreadsheets();

}

bool QuattroParser::parseOLEStream(RVNGInputStreamPtr input, std::string const &avoid)

{

  if (!input || !input->isStructured())

  {

    WPS_DEBUG_MSG(("QuattroParser::parseOLEStream: oops, can not find the input stream\n"));

    return false;

  }

  std::map<std::string, size_t> dirToIdMap;

  WPSOLEParser oleParser(avoid, getDefaultFontType(),

                         [&dirToIdMap](std::string const &dir)

  {

    if (dirToIdMap.find(dir)==dirToIdMap.end())

      dirToIdMap[dir]=dirToIdMap.size();

    return int(dirToIdMap.find(dir)->second);

  });

  oleParser.parse(input);

  oleParser.updateMetaData(m_state->m_metaData);

  auto objectMap=oleParser.getObjectsMap();

  std::map<librevenge::RVNGString, WPSEmbeddedObject> nameToObjectsMap;

  for (auto it : dirToIdMap)

  {

    if (it.first.empty()) continue;

    for (int wh=0; wh<2; ++wh)

    {

      std::string name=it.first+"/"+(wh==0 ? "LinkInfo" : "BOlePart");

      RVNGInputStreamPtr cOle(input->getSubStreamByName(name.c_str()));

      if (!cOle)

      {

        WPS_DEBUG_MSG(("QuattroParser::parseOLEStream: oops, can not find link info for dir %s\n", name.c_str()));

        continue;

      }

      libwps::DebugFile asciiFile(cOle);

      asciiFile.open(libwps::Debug::flattenFileName(name));

      if (wh==1)

        readOleBOlePart(std::make_shared<WPSStream>(cOle,asciiFile));

      else

      {

        librevenge::RVNGString linkName;

        if (readOleLinkInfo(std::make_shared<WPSStream>(cOle,asciiFile),linkName) && !linkName.empty())

        {

          if (objectMap.find(int(it.second))==objectMap.end())

          {

            WPS_DEBUG_MSG(("QuattroParser::parseOLEStream: oops, can not find embedded data for %s\n", name.c_str()));

            continue;

          }

          nameToObjectsMap[linkName]=objectMap.find(int(it.second))->second;

        }

      }

    }

  }

  if (!nameToObjectsMap.empty())

    m_graphParser->storeObjects(nameToObjectsMap);

  return true;

}

bool QuattroParser::readOLEZones(std::shared_ptr<WPSStream> &stream)

{

  if (!stream)

    return false;

  RVNGInputStreamPtr input = stream->m_input;

  libwps::DebugFile &ascFile=stream->m_ascii;

  libwps::DebugStream f;

  f << "Entries(OLEData)[header]:";

  long pos = input->tell();

  long endPos = stream->m_eof;

  if (!stream->checkFilePosition(pos+18))

  {

    WPS_DEBUG_MSG(("QuattroParser::readOLEZones: the zone seems to short\n"));

    ascFile.addPos(pos);

    ascFile.addNote(f.str().c_str());

    return false;

  }

  for (int i=0; i<4; ++i)   // 0

  {

    auto val=int(libwps::read16(input));

    if (val) f << "f" << i << "=" << val << ",";

  }

  auto sSz=long(libwps::readU32(input));

  librevenge::RVNGString text; // QPW$ExtendedStorage$6.0

  if (sSz<=0 || sSz > endPos-input->tell()-6 || !readCString(stream,text,sSz))

  {

    WPS_DEBUG_MSG(("QuattroParser::readOLEZones: can not read header's type\n"));

    f << "##sSz,";

    ascFile.addPos(pos);

    ascFile.addNote(f.str().c_str());

    return true;

  }

  f << "type=" << text.cstr() << ",";

  ascFile.addPos(pos);

  ascFile.addNote(f.str().c_str());

  while (input->tell()+6<=endPos)

  {

    pos=input->tell();

    f.str("");

    f << "OLEData:";

    auto type=int(libwps::read16(input));

    sSz=long(libwps::readU32(input));

    if (sSz < 0 || sSz > endPos-pos-6 || type<1 || type>2 || (sSz==0 && type==2))

    {

      input->seek(pos, librevenge::RVNG_SEEK_SET);

      break;

    }

    if (type==1)

    {

      if (sSz)

        f << "###sz=" << sSz << ",";

      f << "end,";

      ascFile.addPos(pos);

      ascFile.addNote(f.str().c_str());

      return true;

    }

    ascFile.addPos(pos);

    ascFile.addNote(f.str().c_str());

    unsigned long numRead;

    const unsigned char *data=input->read(static_cast<unsigned long>(sSz), numRead);

    if (data && long(numRead)==sSz)

    {

      auto ole=libwps_OLE::getOLEInputStream(std::make_shared<WPSStringStream>(data, unsigned(numRead)));

      if (!ole)

      {

        WPS_DEBUG_MSG(("QuattroParser::readOLEZones::readOLE: oops, can not decode the ole\n"));

      }

      else

      {

        /* normally /_Date_XXX/ Where Date~1507005964 and XXX is an hexadecimal data.

           Moreever, a file can be saved many times, so must read /_Date_XXX/ to retrieve the correspondance

         */

        ascFile.skipZone(pos+6, pos+6+sSz-1);

        parseOLEStream(ole);

      }

    }

    else

    {

      WPS_DEBUG_MSG(("QuattroParser::readOLEZones::readOLE: I can not find the data\n"));

      input->seek(pos, librevenge::RVNG_SEEK_SET);

      break;

    }

    input->seek(pos+6+sSz, librevenge::RVNG_SEEK_SET);

  }

  if (input->tell()<endPos)

  {

    WPS_DEBUG_MSG(("QuattroParser::readOLEZones: find extra data\n"));

    ascFile.addPos(input->tell());

    ascFile.addNote("OLEData:###extra");

  }

  return true;

}

bool QuattroParser::readZone(std::shared_ptr<WPSStream> &stream)

{

  if (!stream)

    return false;

  RVNGInputStreamPtr input = stream->m_input;

  libwps::DebugFile &ascFile=stream->m_ascii;

  libwps::DebugStream f;

  long pos = input->tell();

  auto id = int(libwps::readU16(input));

  auto sz = long(libwps::readU16(input));

  if (sz<0 || !stream->checkFilePosition(pos+4+sz))

  {

    WPS_DEBUG_MSG(("QuattroParser::readZone: size is bad\n"));

    input->seek(pos, librevenge::RVNG_SEEK_SET);

    return false;

  }

  if (id&0x8000)

  {

    // very rare, unsure what this means ; is it possible to have

    // other flags here ?

    WPS_DEBUG_MSG(("QuattroParser::readZone: find type[8] flags\n"));

    ascFile.addPos(pos);

    ascFile.addNote("#flag8000,");

    id &= 0x7fff;

  }

  if (id>=0x800) // I never found anything biggest than 47d, so must be ok

  {

    input->seek(pos, librevenge::RVNG_SEEK_SET);

    return false;

  }

  if (sz>=0xFF00 && stream->checkFilePosition(pos+4+sz+4))

  {

    input->seek(pos+4+sz, librevenge::RVNG_SEEK_SET);

    if (libwps::readU16(input)==0x10f)

    {

      // incomplete block, we must rebuild it

      input->seek(pos, librevenge::RVNG_SEEK_SET);

      unsigned long numRead;

      const unsigned char *data=input->read(4+static_cast<unsigned long>(sz), numRead);

      if (data && long(numRead)==4+sz)

      {