/*
      _______                           __  __    __    __                 
      \      \    ____   __ __ _______ |__||  |  |  |  |__|  ____    ____  
      /   |   \ _/ __ \ |  |  \\_  __ \|  ||  |  |  |  |  | /  _ \  /    \ 
     /    |    \\  ___/ |  |  / |  | \/|  ||  |__|  |__|  |(  <_> )|   |  \
     \____|__  / \___  >|____/  |__|   |__||____/|____/|__| \____/ |___|  /
    =========\/======\/=================================================\/==
  v0.01 03/AUG/2007 (C) Copyright 2007-2007 Scott D. Yelich SOME RIGHTS RESERVED
 .,-*~'`^`'~*-,._.,-*~'`^`'~*-,._.,-*~'`^`'~*-,._.-*~'`^`'~*-,._.,-*~'`^`'~*-,. 


  LICENSE:  Creative Commons Attribution 3.0 License.
  SEE:      http://creativecommons.org/licenses/by/3.0/


  Mon Aug 13 23:19:12 EDT 2007, v0.01 sdy

  This is a *very* simple program written to do test basic sqlite3 
  functionality.

*/


//  C++

#include <iostream>
#include <sstream>
#include <ctime>

//  C

#include <fcntl.h>
#include <errno.h>

//  Yeah, I know I should include the sqlite3.h header file to 
//  get these defined officially -- as this hard coding would
//  break if the values ever changed -- but this is just a 
//  quick example ...
unsigned int const sqlite3_pending_byte = 0x40000000;
unsigned int const sqlite3_reserved_byte = sqlite3_pending_byte+1;

int
msleep(int ms)
{
  struct timespec ts;
  ts.tv_sec = ms / 1000;
  ts.tv_nsec = 1000000 * ( ms - ( ts.tv_sec*1000 ) );
  while(nanosleep(&ts,&ts) == -1) { continue; } // sleep for full period ...
  return 1;
}

int
main(int argc, char **argv)
{

  int fd;
  struct flock fl;
  int tps = 10;
  int rc;

  if ( argv[1] ) {
    std::cerr << "argv[1]=("<<argv[1]<<")\n";
    std::istringstream iss(argv[1]);
    long x = 0;
    iss >> x;
    if ( x>0 && x<100 ) {
      tps = x;
    }
    std::cerr << "tps=("<<tps<<")\n";
  }

  fd = open("data.db", O_RDWR|O_EXCL);
  if (fd == -1) {
    std::cerr << "fd error\n";
    exit(1);
  }

  //  Ya, I could do some timing and figure out the exact value for this ...
  //  but this guess is good enough:
  int startup = 10; // just a ballpark guess 
  int ms = (1000-startup*tps)/tps;
  if (ms < 0) { ms = 0; }

  int rtry = 0;

  fl.l_whence = SEEK_SET;
  fl.l_start = sqlite3_reserved_byte;
  fl.l_len = 1;

  while (1) {

    //  either read or write lock will work for locking sqlite3:
//    fl.l_type = F_RDLCK;  // either READ or WRITE will work.
    fl.l_type = F_WRLCK;  // either READ or WRITE will work.

    if (fcntl(fd, F_SETLK, &fl) == -1) {
      if (errno == EACCES || errno == EAGAIN) {
        rtry++;
        rc = msleep(ms/10);
      } else {
        std::cerr << "unexpected error=("<<errno<<")\n";
        perror("unexpected");
        break;
      }
    } else {
      if ( rtry > 0 ) {
        std::cerr << rtry;
        rtry =0;
      }
      std::cerr << ":";
      rc = msleep(ms/2);
      fl.l_type = F_UNLCK;
      if (fcntl(fd, F_SETLK, &fl) == -1) {
        std::cerr << "unexpected error=("<<errno<<")\n";
        perror("unexpected");
        break;
      }
      std::cerr << ".";
      rc = msleep(ms/2);
    }

  }

}