#include <stdio.h>
#include <string.h>
#include "picoexif.h"

unsigned char exif_buf[EXIF_MAXBUF];  // raw buffer for data, PUBLIC

//  EXIF file format: https://www.media.mit.edu/pia/Research/deepview/exif.html
//  EXIF tag type list: https://www.exiv2.org/tags.html

// vartype type   length
//  0      --
//  1      uint8  1
//  2      string 1   items=number of bytes
//  3      uint16 2
//  4      uint32 4
//  5      uratio 4   2 bytes for numerator, then 2 bytes for denominator
//  6      sint8  1
//  7      undef  1
//  8      sint16 2
//  9      sint32 4
// 10      sratio 8
// 11      float  4
// 12      double 8


// counters and pointers
int exif_itemcnt;   // incremented by exif_additem, PUBLIC
int exif_varbuflen; // offset from start of varbuffer, PUBLIC
int exif_errno=0;   // error (too many items, or insufficient varbuffer, 0 if none)


// set 4-byte integer in raw buffer
void exif_setlong(int offs,unsigned long v){
  exif_buf[offs]=v;v>>=8;
  exif_buf[offs+1]=v;v>>=8;
  exif_buf[offs+2]=v;v>>=8;
  exif_buf[offs+3]=v;
}

unsigned long exif_getlong(int offs){
  return (exif_buf[offs]<<0)+(exif_buf[offs+1]<<8)+(exif_buf[offs+2]<<16)+(exif_buf[offs+3]<<24);
}


// set 2-byte integer in raw buffer
void exif_setint(int offs,int v){
  exif_buf[offs]=v;v>>=8;
  exif_buf[offs+1]=v;
}

int exif_getint(int offs){
  return (exif_buf[offs]<<0)+(exif_buf[offs+1]<<8);
}


// set string s in raw buffer, optionally null-terminated
// returns length of string incl. null
int exif_setstr(int offs,char*s,int nullterm){
  int strl=0;
  while(s[0]){exif_buf[offs]=s[0];s++;offs++;strl++;} // copy, increment variables
  if(nullterm){exif_buf[offs]=0;strl++;} // null-terminate
  return strl;
}

// add string to variable-length buffer, return -1 if overflow, otherwise return raw-buffer address where it is saved to
int exif_addbufstr(char*s){
  if( (strlen(s)+exif_varbuflen+1) >= EXIF_MAXVARBUFLEN ) return -1;   // safety check to not write more to buffer than allowed
  int offs=exif_varbuflen;
  exif_varbuflen=exif_varbuflen+exif_setstr(EXIF_BUF_VARBUFSTART+exif_varbuflen,s,1);
  return offs+EXIF_BUF_VARBUFSTART;
}

// raw buffer offset from directory record number
int exif_getrecordoffs(int record){
  return EXIF_INTERNAL_BUF_FIRSTDIR+EXIF_INTERNAL_ITEMLEN*record;
}



// for exif_subtractoffsptr() - accesss the record type, value

int  exif_getrecordtype(int record)        { return exif_getint(exif_getrecordoffs(record)+EXIF_RECORDOFFSET_TYPE); }
void exif_setrecordtype(int record,int val){ exif_setint(exif_getrecordoffs(record)+EXIF_RECORDOFFSET_TYPE,val); }

long exif_getrecordval(int record)        { return exif_getlong(exif_getrecordoffs(record)+EXIF_RECORDOFFSET_VAL); }
void exif_setrecordval(int record,int val){ exif_setlong(exif_getrecordoffs(record)+EXIF_RECORDOFFSET_VAL,val); }

//long exif_getrecordlen(int record){ return exif_getlong(exif_getrecordoffs(record)+EXIF_RECORDOFFSET_LEN); }



// convert pointer values to remove the unused directory entries
void exif_subtractoffsptr(){
  int diff=EXIF_INTERNAL_ITEMLEN*(EXIF_MAXITEMS-exif_itemcnt);
  for(int t=0;t<exif_itemcnt;t++){
    if(exif_getrecordtype(t)<EXIF_VARTYPE_ISPOINTER)continue;           // detect "pointer" bit, skip if not present
    exif_setrecordtype(t,exif_getrecordtype(t)-EXIF_VARTYPE_ISPOINTER); // remove "pointer" bit
    exif_setrecordval(t,exif_getrecordval(t)-diff);                 // adjust pointer
  }
}



// set EXIF directory record, raw
// items: number of items; physical length is items*vartype[len]
// value: for 1..4 bytes the value itself, otherwise offset to buffer
// rec = record number, type/vartype/items/val are raw data for the dir entry
// ASSUMPTION: only up to 4-byte data here!!!
// CAUTION: no support for larger arrays, optional var-buffer allocation is via exif_addbufstr, and pointer goes here
void exif_setdir(int record,int type,int vartype,long items,unsigned long val){
  int offs=exif_getrecordoffs(record);
  exif_setint(offs+EXIF_RECORDOFFSET_ITEM,type);          // 2-byte, variable meaning from table
  exif_setint(offs+EXIF_RECORDOFFSET_TYPE,vartype);       // variable type; 1=uint8,1; 2=string,1; 3=sint8, ...
  exif_setlong(offs+EXIF_RECORDOFFSET_LEN,items);         // number of variables; total length is length(vartype)*items
  exif_setlong(offs+EXIF_RECORDOFFSET_VAL,val);
}



// ===============================================================================
// PUBLIC FUNCTIONS - exposed via picoexif.h


// user function, main API call for adding a 1..4 byte long variable to directory array, PUBLIC
void exif_additem(int type,int vartype,long items,long val){
  if(exif_itemcnt>=(EXIF_MAXITEMS)){
    exif_errno=EXIF_ERR_TOOMANYITEMS;
#ifdef EXIF_DEBUG_PRINTERR
    fprintf(stderr,"ERROR: too many items, skipping\n");
#endif
    return;
  }
  exif_setdir(exif_itemcnt,type,vartype,items,val);
  exif_itemcnt++;
}



// user function, main API call for adding a string variable to directory array and to var-buffer, PUBLIC
void exif_additemstr(int type,char*s){
  if(exif_itemcnt>=(EXIF_MAXITEMS)){
    exif_errno=EXIF_ERR_TOOMANYITEMS_STR;
#ifdef EXIF_DEBUG_PRINTERR
    fprintf(stderr,"ERROR: too many items, skipping (str)\n");
#endif
    return;
  }
  int len=strlen(s);
  if(len<5){ // fits the directory item, so no var-buffer allocation
    unsigned long l=0;
    for(int t=0;t<len;t++){l=(l<<8)+s[len-t-1];} // order bytes to int
    exif_setdir(exif_itemcnt,type,EXIF_VARTYPE_STR,len,l);
  }else{
    int offs=exif_addbufstr(s);
    if(offs<0){ // not enough space in var-buffer, fail
      exif_errno=EXIF_ERR_STRTOOLONG;
#ifdef EXIF_DEBUG_PRINTERR
      fprintf(stderr,"ERROR: string doesn't fit to remaining var buffer! [%s]\n",s);
#endif
      return;
    }
    exif_setdir(exif_itemcnt,type,EXIF_VARTYPE_STR+EXIF_VARTYPE_ISPOINTER,len+1,offs-10); // len+1 for null termination, 0x1000 added to variable type to signal it is a pointer
  }
  exif_itemcnt++;
}


// user function, call to initialize the array, PUBLIC
void exif_init(){
#ifdef EXIF_DEBUG_MARKBUFFER
  memset(exif_buf,'@',EXIF_MAXBUF);
#else
#ifdef EXIF_WIPEBUFFER
  memset(exif_buf,0,EXIF_MAXBUF);
#endif
#endif
  exif_buf[0]=0xFF;exif_buf[1]=0xE1;                             // JFIF EXIF chunk marker, FFE1
  exif_buf[4]=0x45;exif_buf[5]=0x78;exif_buf[6]=0x69;exif_buf[7]=0x66;exif_buf[8]=0x00;exif_buf[9]=0x00;  // EXIF header, constant
  exif_buf[0xa]=0x49;exif_buf[0xb]=0x49;exif_buf[0xc]=0x2a;exif_buf[0xd]=0x00;    // TIFF header, constant
  //
  exif_setlong(0x0e,8);                                       // offset to first IFD
  //
  exif_itemcnt=0;
  exif_varbuflen=0;
  exif_errno=EXIF_ERR_NONE;
}


// returns total header length; for output, PUBLIC
int exif_gethdrlen(){
  return exif_itemcnt*EXIF_INTERNAL_ITEMLEN+EXIF_INTERNAL_BUF_FIRSTDIR+EXIF_INTERNAL_DIR_PADDING;   // length of first part, with fixed items
}


// user function, call to finish the exif generation; calculates lengths and adjusts pointers, PUBLIC
void exif_finish(){
  int len=exif_gethdrlen()+exif_varbuflen;                     // total length - first part with fixed items, plus variable-length items buffer
  exif_setlong(EXIF_INTERNAL_BUF_FIRSTDIR+exif_itemcnt*EXIF_INTERNAL_ITEMLEN,0);  // end of IFD chain
  exif_setint(EXIF_INTERNAL_BUF_ITEMSOFFS,exif_itemcnt);              // set number of entries;   exif_buf[0x12]=IFD0 entries LSB;exif_buf[0x13]=entries MSB
  exif_subtractoffsptr();                                    // subtract diff from pointers
  exif_buf[2]=(len-2)>>8;exif_buf[3]=(len-2);                // total length of the output, minus the two bytes of FFE1 chunk header; endianness, cannot use exif_setint()
}