/*  MasqMail
    Copyright (C) 2000 Oliver Kurth

    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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "masqmail.h"

header_name header_names[] =
{
  { "From", HEAD_FROM, },
  { "Sender", HEAD_SENDER, },
  { "To", HEAD_TO, },
  { "Cc", HEAD_CC, },
  { "Bcc", HEAD_BCC, },
  { "Date", HEAD_DATE, },
  { "Message-Id", HEAD_MESSAGE_ID, },
  { "Reply-To", HEAD_REPLY_TO, },
  { "Subject", HEAD_SUBJECT, },
  { "Return-Path", HEAD_RETURN_PATH, },
  { "Envelope-To", HEAD_ENVELOPE_TO, },
  { "Received", HEAD_RECEIVED },
};

/* this was borrowed from exim and slightly changed */
gchar *rec_timestamp()
{
  static gchar buf[64];
  int len;
  
  time_t now = time(NULL);
  struct tm *t = localtime(&now);

  int diff_hour, diff_min;
  struct tm local;
  struct tm *gmt;

  memcpy(&local, t, sizeof(struct tm));
  gmt = gmtime(&now);
  diff_min = 60*(local.tm_hour - gmt->tm_hour) + local.tm_min - gmt->tm_min;
  if (local.tm_year != gmt->tm_year)
    diff_min += (local.tm_year > gmt->tm_year)? 1440 : -1440;
  else if (local.tm_yday != gmt->tm_yday)
    diff_min += (local.tm_yday > gmt->tm_yday)? 1440 : -1440;
  diff_hour = diff_min/60;
  diff_min  = abs(diff_min - diff_hour*60);

  len = strftime(buf, sizeof(buf), "%a, ", &local);
  g_snprintf(buf + len, sizeof(buf) - len, "%02d ", local.tm_mday);
  len += strlen(buf + len);
  len += strftime(buf + len, sizeof(buf) - len, "%b %Y %H:%M:%S", &local);
  g_snprintf(buf + len, sizeof(buf) - len, " %+03d%02d", diff_hour, diff_min);

  return buf;
}

/* finds list of headers matching id
   if id == HEAD_UNKNOWN and header == NULL finds all unknown headers
   else finds all headers matching header
*/
GList *find_header(GList *hdr_list, header_id id, gchar *hdr_str)
{
  GList *found_list = NULL;
  GList *node;

  if((id != HEAD_UNKNOWN) || (hdr_str == NULL)){
    foreach(hdr_list, node){
      header *hdr = (header *)(node->data);
      if(hdr->id == id)
        found_list = g_list_append(found_list, hdr);
    }
  }else{
    foreach(hdr_list, node){
      header *hdr = (header *)(node->data);
      gchar buf[64], *q = buf, *p = hdr->header;
      
      while(*p != ':' && q < buf+63 && *p) *(q++) = *(p++);
      *q = 0;
      
      if(strcasecmp(buf, hdr_str) == 0)
        found_list = g_list_append(found_list, hdr);
    }
  }
  return found_list;
}

void header_unfold(header *hdr)
{
  gchar *tmp_hdr = g_malloc(strlen(hdr->header));
  gchar *p = hdr->header, *q = tmp_hdr;
  gboolean flag = FALSE;

  while(*p){
    if(*p != '\n')
      *(q++) = *p;
    else
      flag = TRUE;
    p++;
  }
  *(q++) = '\n';

  if(flag){
    gchar *new_hdr;

    g_free(hdr->header);
    new_hdr = g_strdup(tmp_hdr);
    g_free(tmp_hdr);
    hdr->value = new_hdr + (hdr->value - hdr->header);
    hdr->header = new_hdr;
  }
}

#define MAX_HDR_LEN 72
void header_fold(header *hdr)
{
  gint len = strlen(hdr->header);
  gchar *p, *q;
  /* size is probably overestimated, but so we are on the safe side */
  gchar *tmp_hdr = g_malloc(len + 2*len/MAX_HDR_LEN);

  p = hdr->header;
  q = tmp_hdr;

  if(p[len-1] == '\n')
    p[len-1] = 0;

  while(*p){
    gint i,l;
    gchar *pp;
    
    /* look forward and find potential break points */
    i = 0; l = -1;
    pp = p;
    while(*pp && (i < MAX_HDR_LEN)){
      if((*pp == ' ') || (*pp == '\t'))
	l = i;
      pp++;
      i++;
    }
    if(!*pp) l = pp-p; /* take rest, if EOS found */

    if(l == -1){
      /* no potential break point was found within MAX_HDR_LEN
       so advance further until the next */
      while(*pp && *pp != ' ' && *pp != '\t'){
	pp++;
	i++;
      }
      l = i;
    }

    /* copy */
    i = 0;
    while(i < l){
      *(q++) = *(p++);
      i++;
    }
    *(q++) = '\n';
    *(q++) = *(p++); /* this is either space, tab or 0 */
  }
  {
    gchar *new_hdr;
    
    g_free(hdr->header);
    new_hdr = g_strdup(tmp_hdr);
    g_free(tmp_hdr);
    hdr->value = new_hdr + (hdr->value - hdr->header);
    hdr->header = new_hdr;
  }
}

header *create_header(header_id id, gchar *fmt, ...)
{
  gchar *p;
  header *hdr;
  va_list args;
  va_start(args, fmt);

  if((hdr = g_malloc(sizeof(header)))){

    hdr->id = id;
    hdr->header = g_strdup_vprintf(fmt, args);
    hdr->value = NULL;

    p = hdr->header;
    while(*p && *p != ':') p++;
    if(*p)
      hdr->value = p+1;
  }

  va_end(args);
  return hdr;
}

void destroy_header(header *hdr)
{
  if(hdr){
    if(hdr->header) g_free(hdr->header);
    g_free(hdr);
  }
}

header *copy_header(header *hdr)
{
  header *new_hdr = NULL;

  if(hdr){
    if((new_hdr = g_malloc(sizeof(header)))){
      new_hdr->id = hdr->id;
      new_hdr->header = g_strdup(hdr->header);
      new_hdr->value = new_hdr->header + (hdr->value - hdr->header);
    }
  }
  return new_hdr;
}

header *get_header(gchar *line)
{
  gchar *p = line;
  gchar buf[64], *q = buf;
  gint i;
  header *hdr;
  
  while(*p && (*p != ':') && (q < buf+63)) *(q++) = *(p++);
  *q = 0;
  
  if(*p != ':') return NULL;

  hdr = g_malloc(sizeof(header));

  hdr->value = NULL;
  p++;

  while(*p && (*p == ' ' || *p == '\t')) p++;
  hdr->value = p;

  for(i = 0; i < HEAD_NUM_IDS; i++){
    if(strcasecmp(header_names[i].header, buf) == 0)
      break;
  }
  hdr->id = (header_id)i;
  hdr->header = g_strdup(line);
  hdr->value = hdr->header + (hdr->value - line);

  DEBUG(4) debugf("header: %d = %s", hdr->id, hdr->header);

  return hdr;
}