// Generate HTML fragment for image.
function htmlImageFragment(image: IParserExtractedImage): string {
  const xw = new XMLWriter()

  xw.startElement('div')
  xw.startElement('img')
  xw.writeAttribute('src', image.url)

  if (image.title) {
    xw.writeAttribute('alt', image.title)
    xw.writeAttribute('title', image.title)
  }

  return xw.toString()
}

export async function generator(values: IFetcherValues) {
  const baseURN = 'urn:mordac:feed:'
  const xw = new XMLWriter(true)
  const aw = new ATOMWriter(xw)

  // Generate a full, standalone, XML document.
  xw.startDocument('1.0', 'utf-8')

  // Generate the feed header.
  aw
    .startFeed(baseURN + 'atom.xml')
    .writeTitle('Mordac’s RSS feed')
    .writeAuthor('Scott Adams')
    .writeContributor('Mordac the Preventer of Information Services')

  // Generate an entry for each value.
  for (const day of Object.keys(values)) {
    // Generate a fake timestamp for each post, so feed readers do not
    // consider them new/updated accidentally.
    const date = new Date(day + 'T13:37:00Z')

    const value: IParserExtractedValues = values[day]

    if (value && value.largeImage && value.largeImage.url) {
      aw
        .startEntry(baseURN + 'entry:' + day, date, date)
        .writeContent(htmlImageFragment(value.largeImage), 'html')

      if (value.largeImage.title) {
        aw.writeTitle(value.largeImage.title)
      }

      aw.endEntry()
    }
  }

  aw.endFeed()
  xw.endDocument()

  await fs.promises.writeFile(outputDir + '/atom.xml', xw.toString())
}

export function dumpXml(
  node: BaseNode,
  options: any
) {

    const addressSpace = node.addressSpace;

    const namespace = node.namespace as NamespacePrivate;

    // make a first visit so that we determine which node to output and in which order
    const nodesToVisit: any = {};

    const dependency = constructNamespaceDependency(namespace);
    const translationTable = constructNamespaceTranslationTable(dependency);

    const xw = new XMLWriter(true);
    xw.translationTable = translationTable;

    visitUANode(node, nodesToVisit, false);

    xw.startDocument({ encoding: "utf-8" });
    xw.startElement("UANodeSet");
    xw.writeAttribute("xmlns:xs", "http://www.w3.org/2001/XMLSchema-instance");
    xw.writeAttribute("xmlns:xsd", "http://www.w3.org/2001/XMLSchema");
    xw.writeAttribute("Version", "1.02");
    xw.writeAttribute("LastModified", (new Date()).toISOString());
    xw.writeAttribute("xmlns", "http://opcfoundation.org/UA/2011/03/UANodeSet.xsd");

    buildUpAliases(node, xw, nodesToVisit);
    writeAliases(xw, nodesToVisit.aliases);

    for (const el of nodesToVisit.elements) {
        el.dumpXML(xw);
    }

    xw.endElement();
    xw.endDocument();
    return xw.toString();
}

export function renderToString(element) {
    const writer = new XMLWriter(true);
    renderToXmlWriter(element, writer);

    return writer.toString();
}

UANamespace.prototype.toNodeset2XML = function(this: UANamespace) {

    const dependency = constructNamespaceDependency(this);
    const translationTable = constructNamespaceTranslationTable(dependency);

    const xw = new XMLWriter(true);
    xw.translationTable = translationTable;

    xw.startDocument({ encoding: "utf-8", version: "1.0" });
    xw.startElement("UANodeSet");

    xw.writeAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
    xw.writeAttribute("xmlns:uax", "http://opcfoundation.org/UA/2008/02/Types.xsd");
    xw.writeAttribute("xmlns", "http://opcfoundation.org/UA/2011/03/UANodeSet.xsd");
    // xx xw.writeAttribute("Version", "1.02");
    // xx xw.writeAttribute("LastModified", (new Date()).toISOString());

    // ------------- Namespace Uris
    xw.startElement("NamespaceUris");

    // xx const namespaceArray = namespace.addressSpace.getNamespaceArray();
    for (const depend of dependency) {
        xw.startElement("Uri");
        xw.text(depend.namespaceUri);
        xw.endElement();
    }

    xw.endElement();

    // ------------- Namespace Uris
    xw.startElement("Models");
    xw.endElement();

    const s: any = {};
    for (const node of _.values(this._nodeid_index)) {
        buildUpAliases(node, xw, s);
    }
    writeAliases(xw, s.aliases);

    xw.visitedNode = {};

    // -------------- writeReferences
    xw.writeComment("ReferenceTypes");
    const referenceTypes = _.values(this._referenceTypeMap).sort(sortByBrowseName);
    for (const referenceType of referenceTypes) {
        dumpReferenceType(xw, referenceType);
    }
    // -------------- ObjectTypes
    xw.writeComment("ObjectTypes");
    const objectTypes = _.values(this._objectTypeMap).sort(sortByBrowseName);
    // xx xw.writeComment(" "+ objectTypes.map(x=>x.browseName.name.toString()).join(" "));
    for (const objectType of objectTypes) {
        if (!xw.visitedNode[_hash(objectType)]) {
            objectType.dumpXML(xw);
        }
    }

    // -------------- VariableTypes
    xw.writeComment("VariableTypes");
    const variableTypes = _.values(this._variableTypeMap).sort(sortByBrowseName);
    // xx xw.writeComment("ObjectTypes "+ variableTypes.map(x=>x.browseName.name.toString()).join(" "));
    for (const variableType of variableTypes) {
        if (!xw.visitedNode[_hash(variableType)]) {
            variableType.dumpXML(xw);
        }
    }

    // -------------- Any thing else
    xw.writeComment("Other Nodes");
    const nodes = _.values(this._nodeid_index).sort(sortByBrowseName);
    // xx xw.writeComment(" "+ nodes.map(x=>x.browseName.name.toString()).join(" "));
    for (const node of nodes) {
        if (!xw.visitedNode[_hash(node)]) {
            node.dumpXML(xw);
        }
    }

    xw.endElement();
    xw.endDocument();
    return xw.toString();
};