/** @file

  A brief file description

  @section license License

  Licensed to the Apache Software Foundation (ASF) under one

  or more contributor license agreements.  See the NOTICE file

  distributed with this work for additional information

  regarding copyright ownership.  The ASF licenses this file

  to you under the Apache License, Version 2.0 (the

  "License"); you may not use this file except in compliance

  with the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software

  distributed under the License is distributed on an "AS IS" BASIS,

  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  See the License for the specific language governing permissions and

  limitations under the License.

 */

/****************************************************************************

  HttpBodyFactory.h

  This implements a user-customizable response message generation system.

  The concept is simple.  Error/response messages are classified into

  several types, each given a name, such as "request/header_error".

  The HttpBodyFactory can build a message body for each response type.

  The user can create custom message body text for each type (stored

  in a text file directory), containing templates with space-holders for

  variables which are inline-substituted with current values.  The resulting

  body is dynamically allocated and returned.

  The major data types implemented in this file are:

    HttpBodyFactory       The main data structure which is the machine

                          that maintains configuration information, reads

                          user error message template files, and performs

                          the substitution to generate the message bodies.

    HttpBodySet           The data structure representing a set of

                          templates, including the templates and metadata.

    HttpBodyTemplate      The template loaded from the directory to be

                          instantiated with variables, producing a body.

 ****************************************************************************/

#pragma once

#include <strings.h>

#include <sys/types.h>

#include "tscore/ink_platform.h"

#include "proxy/hdrs/HTTP.h"

#include "proxy/http/HttpConfig.h"

#include "proxy/hdrs/HttpCompat.h"

#include "proxy/http/HttpTransact.h"

#include "tscore/ink_sprintf.h"

#include <memory>

#include <unordered_map>

#define HTTP_BODY_TEMPLATE_MAGIC 0xB0DFAC00

#define HTTP_BODY_SET_MAGIC      0xB0DFAC55

#define HTTP_BODY_FACTORY_MAGIC  0xB0DFACFF

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

//

//      class HttpBodyTemplate

//

//      An HttpBodyTemplate object represents a template with HTML

//      text, and unexpanded log fields.  The object also has methods

//      to dump out the contents of the template, and to instantiate

//      the template into a buffer given a context.

//

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

class HttpBodyTemplate

{

public:

  HttpBodyTemplate();

  ~HttpBodyTemplate();

  void reset();

  int  load_from_file(char *dir, char *file);

  bool

  is_sane()

  {

    return (magic == HTTP_BODY_TEMPLATE_MAGIC);

  }

  char *build_instantiated_buffer(HttpTransact::State *context, int64_t *length_return);

  unsigned int magic;

  int64_t      byte_count;

  char        *template_buffer;

  char        *template_pathname;

};

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

//

//      class HttpBodySetRawData

//

//      Raw data members of HttpBodySet

//

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

class HttpBodySetRawData

{

public:

  using TemplateTable = std::unordered_map<std::string, std::unique_ptr<HttpBodyTemplate>>;

  virtual ~HttpBodySetRawData() {}

  unsigned int                   magic = 0;

  char                          *set_name;

  char                          *content_language;

  char                          *content_charset;

  char                          *content_type;

  std::unique_ptr<TemplateTable> table_of_pages;

};

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

//

//      class HttpBodySet

//

//      An HttpBodySet object represents a set of body factory

//      templates.  It includes operators to get the hash table of

//      templates, and the associated metadata for the set.

//

//      The raw data members come from HttpBodySetRawData above

//

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

class HttpBodySet : public HttpBodySetRawData

{

public:

  HttpBodySet();

  ~HttpBodySet();

  int init(char *set_name, char *dir);

  bool

  is_sane()

  {

    return (magic == HTTP_BODY_SET_MAGIC);

  }

  HttpBodyTemplate *get_template_by_name(const char *name);

  void              set_template_by_name(const char *name, std::unique_ptr<HttpBodyTemplate> t);

};

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

//

//      class HttpBodyFactory

//

//      An HttpBodyFactory object is the main object which keeps track

//      of all the response body templates, and which provides the

//      methods to create response bodies.

//

//      Once an HttpBodyFactory object is initialized, and the template

//      data has been loaded, the HttpBodyFactory object allows the

//      caller to make error message bodies w/fabricate_with_old_api

//

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

class HttpBodyFactory

{

public:

  using BodySetTable = std::unordered_map<std::string, HttpBodySetRawData *>;

  HttpBodyFactory();

  ~HttpBodyFactory();

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

  // primary user APIs //

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

  char *fabricate_with_old_api(const char *type, HttpTransact::State *context, int64_t max_buffer_length,

                               int64_t *resulting_buffer_length, char *content_language_out_buf, size_t content_language_buf_size,

                               char *content_type_out_buf, size_t content_type_buf_size, int format_size, const char *format);

  char *

  getFormat(int64_t max_buffer_length, int64_t *resulting_buffer_length, const char *format, ...)

  {

    char *msg = nullptr;

    if (format) {

      va_list ap;

      va_start(ap, format);

      // The length from ink_bvsprintf includes the trailing NUL, so adjust the final

      // length accordingly. Note that ink_bvsprintf() copies the va_list, so we only

      // have to set it up once.

      int l = ink_bvsprintf(nullptr, format, ap);

      if (l <= max_buffer_length) {

        msg                      = (char *)ats_malloc(l);

        *resulting_buffer_length = ink_bvsprintf(msg, format, ap) - 1;

      }

      va_end(ap);

    }

    return msg;

  }

  void               dump_template_tables(FILE *fp = stderr);

  void               reconfigure();

  static const char *determine_set_by_language(std::unique_ptr<BodySetTable> &table_of_sets, StrList *acpt_language_list,

                                               StrList *acpt_charset_list, float *Q_best_ptr, int *La_best_ptr, int *Lc_best_ptr,

                                               int *I_best_ptr);

  bool is_response_suppressed(HttpTransact::State *context);

private:

  char *fabricate(StrList *acpt_language_list, StrList *acpt_charset_list, const char *type, HttpTransact::State *context,

                  int64_t *resulting_buffer_length, const char **content_language_return, const char **content_charset_return,

                  const char **content_type_return, const char **set_return = nullptr);

  const char       *determine_set_by_language(StrList *acpt_language_list, StrList *acpt_charset_list);

  const char       *determine_set_by_host(HttpTransact::State *context);

  HttpBodyTemplate *find_template(const char *set, const char *type, HttpBodySet **body_set_return);

  bool

  is_sane()

  {

    return (magic == HTTP_BODY_FACTORY_MAGIC);

  }

  void

  sanity_check()

  {

    ink_assert(is_sane());

  }

private:

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

  // initialization methods //

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

  void                          nuke_template_tables();

  std::unique_ptr<BodySetTable> load_sets_from_directory(char *set_dir);

  HttpBodySet                  *load_body_set_from_directory(char *set_name, char *tmpl_dir);

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

  // internal data structure concurrency control //

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

  void

  lock()

  {

    ink_mutex_acquire(&mutex);

  }

  void

  unlock()

  {

    ink_mutex_release(&mutex);

  }

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

  // manager configuration variables //

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

  int  enable_customizations = 0;    // 0:no custom,1:custom,2:language-targeted

  bool enable_logging        = true; // the user wants body factory logging

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

  // internal state //

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

  unsigned int                  magic = HTTP_BODY_FACTORY_MAGIC; // magic for sanity checks/debugging

  ink_mutex                     mutex;                           // prevents reconfig/read races

  bool                          callbacks_established = false;   // all config variables present

  std::unique_ptr<BodySetTable> table_of_sets;                   // sets of template hash tables

};