/*
    LibreCGM, an optical reader for the Freestyle Libre
    Copyright (C) 2021  <email hidden>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 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 Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <string.h>
#include "img.h"

static void search3(struct img* img, int* corner, int edge, signed char dir[2])
{
//printf("search3(corner: %i x %i, dir: %hhi x %hhi)\n", corner[0], corner[1], dir[0], dir[1]);
  int startx=((dir[0]>0)?0:img->w-1);
  int starty=((dir[1]>0)?0:img->h-1);
  int i;
  for(i=0; i<img->w && i<img->h; i++)
  {
    int d;
    for(d=-1; d<2; d+=2)
    {
      int j;
// TODO: Calculate a more reasonable endpoint?
      for(j=0; j<img->w && j<img->h; j++)
      {
// TODO: Somehow reverse the order of this so it goes in a straight line instead of two lines out from the same point? It probably doesn't matter though
        int x=startx+(i+j*d)*dir[0];
        int y=starty+(i-j*d)*dir[1];
        if(x<0 || x>=img->w){continue;}
        if(y<0 || y>=img->h){continue;}
        unsigned char* p=pixel(img, x, y);
        int v=p[0]+p[1]+p[2];
        if(v>edge)
        {
          corner[0]=x;
          corner[1]=y;
          return;
        }
      }
    }
  }
}

static char search(struct img* img, int* corner, int edge, char dir)
{
  int x,y;
  char xinv=0;
  char yinv=0;
  switch(dir)
  {
    case 2: xinv=1; yinv=1; // fall through
    case 0:
      for(y=0; y<img->h; y++)
      {
        for(x=0; x<img->w; x++)
        {
          unsigned char* p=&img->pixels[
            (yinv?img->h-1-y:y) *img->rowstride+
            (xinv?img->w-1-x:x) *img->pixstride];
          int v=p[0]+p[1]+p[2];
          if(v>edge)
          {
            corner[0]=(xinv?img->w-1-x:x);
            corner[1]=(yinv?img->h-1-y:y);
            return 1;
          }
        }
      }
      break;
    case 3:
    case 1:
      if(dir==1){xinv=1;}else{yinv=1;}
      for(x=0; x<img->w; x++)
      {
        for(y=0; y<img->h; y++)
        {
          unsigned char* p=&img->pixels[
            (yinv?img->h-1-y:y) *img->rowstride+
            (xinv?img->w-1-x:x) *img->pixstride];
          int v=p[0]+p[1]+p[2];
          if(v>edge)
          {
            corner[0]=(xinv?img->w-1-x:x);
            corner[1]=(yinv?img->h-1-y:y);
            return 1;
          }
        }
      }
      break;
  }
  return 0;
}

static int triarea(int* rect)
{
  int min[2]={rect[0],rect[1]};
  int max[2]={rect[0],rect[1]};
  int i;
  for(i=1; i<3; i++)
  {
    if(rect[i*2]<min[0]){min[0]=rect[i*2];}
    if(rect[i*2]>max[0]){max[0]=rect[i*2];}
    if(rect[i*2+1]<min[1]){min[1]=rect[i*2+1];}
    if(rect[i*2+1]>max[1]){max[1]=rect[i*2+1];}
  }
  int w=max[0]-min[0];
  int h=max[1]-min[1];
  return (w*h)/2;
}

static int area(int* rect)
{
  int tri[6]={rect[4], rect[5],
              rect[6], rect[7],
              rect[0], rect[1]};
  return triarea(rect)+triarea(tri);
}

int* findrect(struct img* img)
{
  static int rect[8]={0};
  int x,y;
  int min=255*3, max=0;
  for(y=0; y<img->h; y++)
  {
    for(x=0; x<img->w; x++)
    {
      unsigned char* p=&img->pixels[y*img->rowstride+x*img->pixstride];
      int v=p[0]+p[1]+p[2];
      if(v<min){min=v;}
      if(v>max){max=v;}
    }
  }
  int edge=(min*2+max)/3; // Median color value to determine if a pixel hits the screen (except a little lower which gives more accurate results)
  int i;
  int drect[8]={0};
  for(i=0; i<4; i++)
  {
    if(!search(img, &rect[i*2], edge, i)){printf("Failed to find corner %i\n", i);}
    signed char diagonal[]={1-((1-i)&2), 1-((2-i)&2)};
    search3(img, &drect[i*2], edge, diagonal);
  }
/*
printf("Diagonal rectangle: (area: %i)\n", area(drect));
for(i=0; i<4; i++)
{
  printf("  %i x %i\n", drect[i*2], drect[i*2+1]);
}
printf("Plain rectangle: (area: %i)\n", area(rect));
for(i=0; i<4; i++)
{
  printf("  %i x %i\n", rect[i*2], rect[i*2+1]);
}
*/
  if(area(drect)>area(rect))
  {
//    printf("Going with diagonal\n");
    memcpy(rect, drect, sizeof(int)*8);
  }
  return rect;
}