Wt

typedef std::map<std::string, std::string> IdentifierMap;

void fillIdentifierMap(const std::vector<Wt::WString>& args, IdentifierMap& identifier_map) 
{
  std::string vecString;
  for (auto wS: args) 
  {
    vecString = wS.toUTF8();
    // Find the position of the '=' character in the string
    size_t pos = vecString.find('=');

    if (pos != std::string::npos) 
    {
      // Extract the identifier and value part (before and after the '=')
      std::string identifier = vecString.substr(0, pos);
      std::string value = vecString.substr(pos+1);
      // Insert the identifier and its value into the map
      identifier_map[identifier] = value;
    } else {
        std::cerr << "Invalid format, '=' not found in: " << wS << std::endl;
    }
  }
}


class NoRobotsFileResource : public Wt::WFileResource
{
  void handleRequest(const Wt::Http::Request& request, Wt::Http::Response& response) override 
  {
    response.addHeader("X-Robots-Tag", "noindex, noimageindex");
    Wt::WFileResource::handleRequest(request, response);
  }
};

bool secure_img(Wt::WTemplate *t,
            const std::vector<Wt::WString>& args,
            std::ostream& result)
{
  if(args.size() < 1)
  {
    Wt::log("info") << "Template Function secure_img needs at least 1 argument";
    return false;
  }

  IdentifierMap argMap;
  fillIdentifierMap(args, argMap);

  std::string src;

  if(auto src_it = argMap.find("src"); src_it != argMap.end())
  {
    if(src_it->second.compare(0, 1, "/") == 0)
    {
      src = src_it->second;
    } 
    else 
      if(src_it->second.compare(0, 1, "$") == 0)
      {
        src = t->resolveStringValue(src_it->second).toUTF8();
      }

    // erase item to later be able to loop over leftover attributes
    argMap.erase(src_it);
  } 
  else 
  {
    // Check Argument Vector again for first Item
    // fillIdentifierMap only fills with defined identifier=value pairs

    if(std::string vecSrc = args[0].toUTF8(); vecSrc.compare(0, 1, "/") == 0)
    {
      src = vecSrc;
    } 
    else 
      if(vecSrc.compare(0, 1, "$") == 0)
      {
        src = t->resolveStringValue(vecSrc).toUTF8();
      }
      else
      {
        Wt::log("info") << "Template Function secure_img needs to Start with Path (/) or template Variable ($),\n"
                        << "or have identifier src in the arguments:\n";
        return false;
      }
  }


  auto imgFile = t->addChild(std::make_unique<NoRobotsFileResource>());
  imgFile->setFileName(Wt::WApplication::instance()->appRoot() + src);

  Wt::WImage wimg{};
  wimg.setImageLink(imgFile->generateUrl());

  if(auto alt_it = argMap.find("alt"); alt_it != argMap.end())
  {
    if(alt_it->second.compare(0, 1, "$") == 0)
    {
      if(alt_it->second.find(":") != std::string::npos)
      {
        // might be tr: function
        Wt::log("debug") << "TemplateFunction" << "::secure_img: alt has additional Function?";
        if(alt_it->second.compare(0, 5, "${tr:") == 0)
        {
          std::stringstream ssAlt;
          if(t->resolveFunction("tr",{alt_it->second.substr(5, alt_it->second.size() -6)}, ssAlt))
            wimg.setAlternateText(ssAlt.str());
        }
      }
      else // it's just a bound string
        wimg.setAlternateText(t->resolveStringValue(alt_it->second));
    }
    else // it's just text
      wimg.setAlternateText(alt_it->second);

    // erase item to later be able to loop over leftover attributes
    argMap.erase(alt_it);
  }

  if(auto class_it = argMap.find("class"); class_it != argMap.end())
  {
    wimg.addStyleClass(class_it->second);

    // erase item to later be able to loop over leftover attributes
    argMap.erase(class_it);
  }

  // Add all left over Attributes
  for(auto attr : argMap)
  {
    wimg.setAttributeValue(attr.first, attr.second);
  }

  wimg.htmlText(result);

  return true;
}