/*************************************************************************
 *
 * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <sh/htc.h>
#include <hdb/buffer.h>
#include <http/http.h>

static const charset htcmask("{}\\%&*$;");
static const charset htmlmask("<&>\"");

static void Mask(mstream& out,const charset& mask,const sref& msg)
{
  sref q,p=msg;
  while(p.nempty()) {
    p=p.adv(q=p.left_first_of(mask));
    out<<q;
    while(mask.test(p.front())) {
      unsigned code=(unsigned char)*p; p=p.popf();
      out<<"&#"<<code<<";";
    }
  }
}

TOK_IMPL(mask_htc) {
  Mask(out,htcmask,env[0]);
}

TOK_IMPL(mask_html) {
  Mask(out,htmlmask,env[0]);
}  

TOK_IMPL(cdata) {
  out.put('\"'); Mask(out,htmlmask,env[0]); out.put('\"');
}

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

TOK_IMPL(wrap) {
  int num=atoi(env[0]);
  sref body=env[1];
  int col=0;
  for(int i=0;i<body.size();i++) {
    if(cset_newl.test(body[i])) col=0; else col++;
    if(cset_spaces.test(body[i])&&col>num) { out.put('\n'); col=0; }
    else out.put(body[i]);
  }
}  

TOK_IMPL(htmlize) {
  sref first,rest=env[0];
  while(Splitln(first,rest)) {
    Mask(out,htmlmask,first);
    out<<"<br>\n";
  }
}  

TOK_IMPL(lf2crlf) {
  LF2CRLF(out,env[0]);
}
TOK_IMPL(crlf2lf) {
  CRLF2LF(out,env[0]);
}

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

TOK_IMPL(twocolumn) {
  int num=atoi(env[0]);
  int page=atoi(env[1]);
  sref head=env[2],mid=env[3],foot=env[4],body=env[5];
  int row=0,col=0,pg=1;
  out<<head;
  for(int i=0;i<body.size()&&pg<=page;i++) {
    if(pg==page) out.put(body[i]);
    if(body[i]=='\n') {
      row++;
      if(row>=num) {
        row=0;
        col++;
        if(col>=2) { col=0; pg++; }
        else if(pg==page) { out<<mid; }
      }
    }
  }
  out<<foot;
}  

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

TOK_IMPL(encode) {
  Pack(out,env[0]);
}

TOK_IMPL(decode) {
  Unpack(out,env[0]);
}

TOK_IMPL(encode_header) {
  encodeHeader(out,mime_default,env[0]);
}

TOK_IMPL(encode_base64) {
  mstring buffer,path=DocPath(env,env[0]);
  LoadBuffer(buffer,path);
  encode64(out,buffer);
}

TOK_IMPL(pack) {
  rrpile pile;
  spile var(env.args);
  for(int i=0;i<env.args;i++) {
    env.parg(var[i],i);
    pile.push_back(rrstring(var[i],env.glob(var[i])));
  }
  Pack(out,pile);
}

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

TOK_IMPL(decode_base64) {
  mstring buffer,name=env.parg(-1),uri=env.URI(env[0]),path=DocPath(env,env[0]);
  LoadBuffer(buffer,path);
  if(name.nempty()) {
    swrite sw(Reference(*env.toks,name,uri,1)->data);
    decode64(sw,buffer);
  }
  else decode64(out,buffer);
}

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

TOK_IMPL(strip) {
  sref s=env[0],a=env[1];
  for(int i=0;i<s.size();i++) if(a.find(s[i])<0) out.put(s[i]);
}

TOK_IMPL(replace) {
  mstring s=env[0]; sref a=env[1],b=env[2];
  if(a!=b) { int p; while((p=s.find(a))>=0) s.replace(p,a.size(),b); }
  out<<s;
}

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

TOK_IMPL(left) {
  int pad=atoi(env[1])-env[0].size();
  out<<env[0]; while(pad-->0) out.put(' ');
}
TOK_IMPL(right) {
  int pad=atoi(env[1])-env[0].size();
  while(pad-->0) out.put(' '); out<<env[0]; 
}

TOK_IMPL(sub) {out<<env[0](atoi(env[1]),atoi(env[2]));}

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

TOK_IMPL(file2mime) {
  const sref* p=file2mime(env[0]);
  if(p) out<<*p; else out<<http_mime_default;
}

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

TOK_IMPL(minilang) {
  static const mstring lang_tag("\\lang");
  sref p=env[0];
  while(p.nempty()) {
    sref e=p.left_first(lang_tag);
    out<<e;
    p=p.adv(e);
    if(p.nempty()) {
      p=p.adv(lang_tag.size());
      e=p.right_first_not_of(cset_ws);
      int n=0,s=e.skip(cset_braces);
      while(s>0) {
        p=e.adv(s);
        if(n==env.req->lang) out<<e(1,s-2);
        e=p.right_first_not_of(cset_ws);
        s=e.skip(cset_braces);
        n++;
      }
      if(n==0) out<<lang_tag;
      if(*p==';') p=p.adv(1);
    }
  }
}

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

void envAddConvert(tokmap& T)
{
  TOK_ADD(mask_htc,"x",tok_t::SYSONLY,
          "%Mask HTC language\n"
          "%Syntax: \\mask.htc{text}\n"
          "%\n"
          "%Converts 'hot' characters to HTML CDATA encoding\n"
          "%CDATA encoding: &#hex;\n"
          );
  TOK_ADD(mask_html,"x",tok_t::PUBLIC,
          "%Mask HTML language\n"
          "%Syntax: \\mask.html{text}\n"
          "%\n"
          "%Converts 'hot' characters to HTML CDATA encoding\n"
          "%CDATA encoding: &#hex;\n"
          );
  TOK_ADD(cdata,"x",tok_t::PUBLIC,
          "%Convert to CDATA\n"
          "%Syntax: \\cdata{text}\n"
          "%\n"
          "%Converts 'hot' characters to HTML CDATA encoding\n"
          "%and encloses in \" characters\n"
          "%\n"
          "%HTML parsors usually does not nest the \" character,\n"
          "%so this function is used extensively in arguments to\n"
          "%HTML commands.\n"
          );

  ///////////////////////////////////////////////
  
  TOK_ADD(wrap,"xx",tok_t::PUBLIC,
          "%Wrap long lines\n"
          "%Syntax: \\wrap{at column}{text}\n"
          "%\n"
          "%Wraps words that extend the given column by inserting\n"
          "%newline characters.\n"
          );
  TOK_ADD(htmlize,"x",tok_t::PUBLIC,
          "%HTMLize plain text\n"
          "%Syntax: \\htmlize{text}\n"
          "%\n"
          "%Inserts a HTML break at each newline.\n"
          );
  TOK_ADD(lf2crlf,"x",tok_t::PUBLIC,
          "%LF to CRLF\n"
          "%Syntax: \\lf2crlf{text}\n"
          "%\n"
          "%Inserts a carriage return (CR) at each newline.\n"
          );
  TOK_ADD(crlf2lf,"x",tok_t::PUBLIC,
          "%CRLF to LF\n"
          "%Syntax: \\crlf2lf{text}\n"
          "%\n"
          "%Removes all carriage return (CR) characters.\n"
          );

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

  TOK_ADD(twocolumn,"xxxxxx",tok_t::PUBLIC,
          "%Output column text\n"
          "%Syntax: \\twocolumn{rows}{page}{head}{mid}{foot}{body}\n"
          );

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

  TOK_ADD(encode,"x",tok_t::PUBLIC,
          "%Encode text\n"
          "%Syntax: \\encode{text}\n"
          "%\n"
          "%Encodes text in x-www-form-urlencoded format (RFC HTTP)\n"
          );
  TOK_ADD(decode,"x",tok_t::PUBLIC,
          "%Decode text\n"
          "%Syntax: \\decode{text}\n"
          "%\n"
          "%Decodes text given in x-www-form-urlencoded format (RFC HTTP)\n"
          );

  TOK_ADD(encode_header,"x",tok_t::PUBLIC,
          "%Encode header\n"
          "%Syntax: \\encode.header{text}\n"
          "%\n"
          "%Encodes text in Quoted-printable header format (RFC MIME)\n"
          );
  TOK_ADD(encode_base64,"x",tok_t::PUBLIC,
          "%Encode base64\n"
          "%Syntax: \\encode.base64{uri}\n"
          "%\n"
          "%Encodes the uri, possible containing binary data,\n"
          "%in BASE64 format (RFC MIME)\n"
          );
  TOK_ADD(decode_base64,"?x",tok_t::PUBLIC,
          "%Decode base64\n"
          "%Syntax: \\decode.base64{var}{uri}\n"
          "%\n"
          "%Encodes the uri, presumed to be in BASE64 format,\n"
          "%and outputs or saves in var. (RFC MIME)\n"
          );
  TOK_ADD(pack,"*",tok_t::PUBLIC,
          "%Encode text\n"
          "%Syntax: \\pack<var><var>..\n"
          "%\n"
          "%Encodes a sequence of variables in\n"
          "%x-www-form-urlencoded format (RFC HTTP)\n"
          );
  
  ///////////////////////////////////////////////

  TOK_ADD(strip,"xx",tok_t::PUBLIC,
          "%Strip text from special characters\n"
          "%Syntax: \\stip{text}{chars}\n"
          );
  TOK_ADD(replace,"xxx",tok_t::PUBLIC,
          "%Replace text\n"
          "%Syntax: \\replace{text}{string}{subst}\n"
          "%\n"
          "%Replaces each occurence of string in text with subst.\n"
          );

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

  TOK_ADD(left,"xx",tok_t::PUBLIC,
          "%Left-adjust text\n"
          "%Syntax: \\left{text}{n}\n"
          "%\n"
          "%Outputs n characters, padding with spaces to the right.\n"
          "%\n"
          "%Writes out the full text if longer than n.\n"
          );
  TOK_ADD(right,"xx",tok_t::PUBLIC,
          "%Right-adjust text\n"
          "%Syntax: \\right{text}{n}\n"
          "%\n"
          "%Outputs n characters, padding with spaces to the left.\n"
          "%\n"
          "%Writes out the full text if longer than n.\n"
          );

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

  TOK_ADD(sub,"xxx",tok_t::PUBLIC,
          "%Substring\n"
          "%Syntax: \\sub{string}{pos}{n}\n"
          "%\n"
          "%Gets a substring of n characters, beginning at pos, from string.\n"
          "%\n"
          "%Negative pos values wraps to end.\n"
          "%Negative n values wraps to 1+size.\n"
          );
  
  ///////////////////////////////////////////////

  TOK_ADD(file2mime,"x",tok_t::PUBLIC,
          "%Get MIME type\n"
          "%Syntax: \\file2mime{path}\n"
          "%\n"
          "%Looks up the MIME type mapped to the extension of path.\n"
          "%\n"
          "%Defaults to application/octet-stream if not found.\n"
          );

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

  TOK_ADD(minilang,"x",tok_t::PUBLIC,
          "%Parse lang only\n"
          "%Syntax: \\minilang{body}\n"
          "%\n"
          "%This function is used to enable lang in html files,\n"
          "%which otherwise are not parsed.\n"
          );
}