#include "funcs.h"

#include "onerr.h"

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

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>




//------- FUNCS

// nothing
 int f_nothing(){
  return 1;
 };



//-------------------------------- -e NAME (exist)
 int f_e(struct EXP *e){
  struct stat st;
  char s1[MAX];

       e++;
  if ( e->n >= 0) {
     strcpy(s1,e->value);
       e--;
//------------
     if ( stat (s1, &st) != 0)
       return 0;
//============
       } else on_error(ERROR_E1);

  return 1;
 };
//-------------------------------- -e NAME (exist)






//-------------------------------- -r NAME (exist)
 int f_r(struct EXP *e){
  struct stat st;
  char s1[MAX];

       e++;
  if ( e->n >= 0) {
     strcpy(s1,e->value);
       e--;
//------------
   if ( access (s1, R_OK))
       return 0;

//============
       } else on_error(ERROR_E1);

  return 1;
 };
//-------------------------------- -r NAME (exist)





//-------------------------------- -w NAME (exist)
 int f_w(struct EXP *e){
  struct stat st;
  char s1[MAX];

       e++;
  if ( e->n >= 0) {
     strcpy(s1,e->value);
       e--;
//------------
   if ( access (s1, W_OK))
       return 0;

//============
       } else on_error(ERROR_E1);

  return 1;
 };
//-------------------------------- -w NAME (exist)



//-------------------------------- -x NAME (exist)
 int f_x(struct EXP *e){
  struct stat st;
  char s1[MAX];

       e++;
  if ( e->n >= 0) {
     strcpy(s1,e->value);
       e--;
//------------
   if ( access (s1, X_OK))
       return 0;

//============
       } else on_error(ERROR_E1);

  return 1;
 };
//-------------------------------- -w NAME (exist)



//-------------------------------- -L NAME (exist)
 int f_L(struct EXP *e){
  char s1[MAX];
  char u[MAX];


       e++;
  if ( e->n >= 0) {
     strcpy(s1,e->value);
       e--;

//------------
  if( readlink(s1, u, MAX) <= -1 )
   return 0;
//============
       } else on_error(ERROR_E1);

  return 1;
 };
//-------------------------------- -L NAME (exist)





//-------------------------------- -f NAME (exist)
 int f_f(struct EXP *e){
  struct stat st;
  char s1[MAX];


      e++;
  if ( e->n >= 0) {
     strcpy(s1,e->value);
       e--;

//------------
     if ( stat (s1, &st) != 0)
       return 0;
        else
         if (st.st_mode != S_IFREG)
          return 0;
//============
       } else on_error(ERROR_E1);

  return 1;
 };
//-------------------------------- -f NAME (exist)




//-------------------------------- -d NAME (exist)
 int f_d(struct EXP *e){
  struct stat st;
  char s1[MAX];


      e++;
  if ( e->n >= 0) {
     strcpy(s1,e->value);
       e--;

//------------
     if ( stat (s1, &st) != 0)
       return 0;

     if (!(st.st_mode & S_IFDIR))
        return 0;
//============
       } else on_error(ERROR_E1);

  return 1;
 };
//-------------------------------- -d NAME (exist)





//-------------------------------- -s NAME (exist)
 int f_s(struct EXP *e){
  struct stat st;
  char s1[MAX];


      e++;
  if ( e->n >= 0) {
     strcpy(s1,e->value);
       e--;

//------------
     if ( stat (s1, &st) != 0)
       return 0;

     if (st.st_size == 0)
        return 0;
//============
       } else on_error(ERROR_E1);

  return 1;
 };
//-------------------------------- -s NAME (exist)




//-------------------------------- -ot NAME (exist)
 int f_ot(struct EXP *e){
  struct stat st,st2;
  char s1[MAX];
  char s2[MAX];


      e++;
  if ( e->n >= 0) {
     strcpy(s1,e->value);
       e--;

       e--;
     strcpy(s2,e->value);

//------------
     if ( stat (s1, &st) != 0 )
       return 0;

     if ( stat (s2, &st2) != 0 )
       return 0;

     if (st.st_mtime > st2.st_mtime)
        return 0;
//============

       } else on_error(ERROR_E1);

  return 1;
 };
//-------------------------------- -ot NAME (exist)






//-------------------------------- -ot NAME (exist)
 int f_nt(struct EXP *e){
  struct stat st,st2;
  char s1[MAX];
  char s2[MAX];


      e++;
  if ( e->n >= 0) {
     strcpy(s1,e->value);
       e--;

       e--;
     strcpy(s2,e->value);

//------------
     if ( stat (s1, &st) != 0 )
       return 0;

     if ( stat (s2, &st2) != 0 )
       return 0;



     if (st.st_mtime < st2.st_mtime)
        return 0;
//============

       } else on_error(ERROR_E1);

  return 1;
 };
//-------------------------------- -ot NAME (exist)







//-------------------------------- -et NAME (exist)
 int f_et(struct EXP *e){
  struct stat st,st2;
  char s1[MAX];
  char s2[MAX];

  char u1[MAX];
  char u2[MAX];
  int s, r2;


      e++;
  if ( e->n >= 0) {
     strcpy(s1,e->value);
       e--;

       e--;
     strcpy(s2,e->value);

//------------
     if ( stat (s1, &st) != 0 )
       return 0;

     if ( stat (s2, &st2) != 0 )
       return 0;

 r2 = 0;

    s = readlink(s1, u1, MAX);
     if (s>0) u1[s] = 0; else r2++;
    s = readlink(s2, u2, MAX);
     if (s>0) u2[s] = 0; else r2++;



   if (r2 == 2 || r2 == 1) return 0;
   if (r2 == 1) return 0;
   if (r2 == 0) if (strcmp(u1, u2)!=0) return 0;

//============

       } else on_error(ERROR_E1);

  return 1;
 };
//-------------------------------- -et NAME (exist)






//========================================== INIT
int funcinit(struct MATRIX  *m){

  m->countfuncs = 0;

 //- Nothing
  strcpy(m->funcs[m->countfuncs].s, " ");
  m->funcs[m->countfuncs].f = f_nothing;
  m->countfuncs++;


  
  
 //- Existing
  strcpy(m->funcs[m->countfuncs].s, "-e");
  m->funcs[m->countfuncs].f = f_e;
  m->countfuncs++;

 //- Reading
  strcpy(m->funcs[m->countfuncs].s, "-r");
  m->funcs[m->countfuncs].f = f_r;
  m->countfuncs++;

 //- Writing
  strcpy(m->funcs[m->countfuncs].s, "-w");
  m->funcs[m->countfuncs].f = f_w;
  m->countfuncs++;

 //- Executing
  strcpy(m->funcs[m->countfuncs].s, "-x");
  m->funcs[m->countfuncs].f = f_x;
  m->countfuncs++;




 //- Link?
  strcpy(m->funcs[m->countfuncs].s, "-L");
  m->funcs[m->countfuncs].f = f_L;
  m->countfuncs++;




 //- File?
  strcpy(m->funcs[m->countfuncs].s, "-f");
  m->funcs[m->countfuncs].f = f_f;
  m->countfuncs++;

 //- Dir?
  strcpy(m->funcs[m->countfuncs].s, "-d");
  m->funcs[m->countfuncs].f = f_d;
  m->countfuncs++;

 //- Size > 0
  strcpy(m->funcs[m->countfuncs].s, "-s");
  m->funcs[m->countfuncs].f = f_s;
  m->countfuncs++;




 //- Size1 < Size2
  strcpy(m->funcs[m->countfuncs].s, "-ot");
  m->funcs[m->countfuncs].f = f_ot;
  m->countfuncs++;

  //- Size1 > Size2
  strcpy(m->funcs[m->countfuncs].s, "-nt");
  m->funcs[m->countfuncs].f = f_nt;
  m->countfuncs++;


 //- Size1 > Size2
  strcpy(m->funcs[m->countfuncs].s, "-et");
  m->funcs[m->countfuncs].f = f_et;
  m->countfuncs++;

 return m->countfuncs == MAX_F;
}