#include "mywin_inc.h"

/******************队列操作相关函数**********************/

// 初始化已实例化的队列
void QUEUE_Init(QUEUE_Struct *q, int blocksize, int blocknum) {
  q->queueByteSize = blocksize * blocknum;
  q->blockByteSize = blocksize;
  q->data = mymalloc(q->queueByteSize);
  q->inPointer = q->data;
  q->outPointer = q->data;
}

// 销毁队列
void QUEUE_Delete(QUEUE_Struct *q) {
  myfree(q->data);
  q->data = 0;
}

// 出队,如果队列为空，返回0，否则返回1
int QUEUE_Out(QUEUE_Struct *q, void *buff) {
  int ret = 0;
  if (q->data == 0)
    return ret;
  if ((q->outPointer != q->inPointer) || q->fill == 1) {
    ret = 1;
    mymemcpy(buff, q->outPointer, q->blockByteSize);
    q->outPointer += q->blockByteSize;
    if (q->outPointer >= q->data + q->queueByteSize)
      q->outPointer = q->data;
    q->fill = 0; // 队列非满
  }
  return ret;
}

// 入队，如果队列已满，返回1并且本次入队失败
int QUEUE_In(QUEUE_Struct *q, void *block) {
  if (q->data == 0)
    return 1;
  if (q->fill == 1)
    return 1;
  mymemcpy(q->inPointer, block, q->blockByteSize);
  q->inPointer += q->blockByteSize;
  if (q->inPointer >= q->data + q->queueByteSize)
    q->inPointer = q->data;
  if (q->inPointer == q->outPointer) // 如果入队指针和出队指针相等，则队列满
    q->fill = 1;
  return 0;
}

// 查看初始化
int QUEUE_CheckStart(QUEUE_Struct *q) {
  if (q->data == 0)
    return 1;
  q->checkPointer = q->checkPointer = q->outPointer;
  if ((q->checkPointer != q->inPointer) || q->fill == 1)
    q->checkEnd = 0;
  else
    q->checkEnd = 1;
  return 0;
}

// 查看数据，还有数据返回，没有数据返回0
void *QUEUE_Check(QUEUE_Struct *q) {
  void *ret = 0;
  if (q->data == 0)
    return ret;
  if (q->checkEnd == 0) {
    ret = q->checkPointer;
    q->checkPointer += q->blockByteSize;
    if (q->checkPointer >= q->data + q->queueByteSize)
      q->outPointer = q->data;
    if (q->checkPointer == q->inPointer)
      q->checkEnd = 1;
  }
  return ret;
}

/****************坐标计算*************************/

// 判断两个点的距离是否超过了半径，没超过返回0，超过了返回非0
int POS_RoundPix(int r, int x1, int y1, int x2, int y2) {
  if ((x1 - x2 > r) || (x2 - x1 > r))
    return -1;
  if ((y1 - y2 > r) || (y2 - y1 > r))
    return -1;
  return 0;
}

// 判断指定点是否在矩形内,1,在，0，不在
int POS_InRect(int rect_x, int rect_y, int rect_x_size, int rect_y_size, int x,
               int y) {
  if (((x >= rect_x) && (x <= rect_x + rect_x_size - 1)) &&
      ((y >= rect_y) && (y <= rect_y + rect_y_size - 1))) {
    return 1;
  } else {
    return 0;
  }
}

// 两个矩形求交集,有交集返回1
int POS_RectIntersection(RECT_Struct *out, RECT_Struct *r1, RECT_Struct *r2) {
  // 取得新矩形的左上角
  int x_s = r1->x;
  int y_s = r1->y;
  if (x_s < r2->x)
    x_s = r2->x;
  if (y_s < r2->y)
    y_s = r2->y;

  // 取得新矩形的右下角
  int x_e = r1->x + r1->x_size - 1;
  int y_e = r1->y + r1->y_size - 1;
  if (x_e > r2->x + r2->x_size - 1)
    x_e = r2->x + r2->x_size - 1;
  if (y_e > r2->y + r2->y_size - 1)
    y_e = r2->y + r2->y_size - 1;
  out->x = x_s;
  out->y = y_s;
  out->x_size = x_e - x_s + 1;
  out->y_size = y_e - y_s + 1;

  if ((y_e >= y_s) && (x_e >= x_s)) {
    return 1;
  } else {
    return 0;
  }
}

// 求一个大矩形，包含两个小矩形
int POS_RectContain(RECT_Struct *out, RECT_Struct *r1, RECT_Struct *r2) {
  // 取得新矩形的左上角
  int x_s = r1->x;
  int y_s = r1->y;
  if (x_s > r2->x)
    x_s = r2->x;
  if (y_s > r2->y)
    y_s = r2->y;

  // 取得新矩形的右下角
  int x_e = r1->x + r1->x_size - 1;
  int y_e = r1->y + r1->y_size - 1;
  if (x_e < r2->x + r2->x_size - 1)
    x_e = r2->x + r2->x_size - 1;
  if (y_e < r2->y + r2->y_size - 1)
    y_e = r2->y + r2->y_size - 1;
  out->x = x_s;
  out->y = y_s;
  out->x_size = x_e - x_s + 1;
  out->y_size = y_e - y_s + 1;
  return 1;
}

// 两个矩形相减，如果r2大于r1,则输出为空矩形
int POS_RectSub(RECT_Struct *out, RECT_Struct *r1, RECT_Struct *r2) {
  RECT_Struct temp = {0};
  out->x = r1->x;
  out->y = r1->y;
  out->x_size = r1->x_size;
  out->y_size = r1->y_size;

  if (POS_RectIntersection(&temp, r1, r2)) {
    // 如果两个矩形有交集
    if (temp.x_size < r1->x_size && temp.y_size < r1->y_size) {
      // 新矩形长和宽都小于原矩形，结果不受影响
      return 1;
    } else if ((temp.x > r1->x &&
                (temp.x + temp.x_size < r1->x + r1->x_size)) ||
               (temp.y > r1->y &&
                (temp.y + temp.y_size < r1->y + r1->y_size))) {
      // 新矩形在原矩形的中间，结果不受影响
      return 1;
    } else if (POS_RectEqual(&temp, r1)) {
      // 新矩形与原矩形相等，结果返回0
      out->x = 0;
      out->x_size = 0;
      out->y = 0;
      out->y_size = 0;
      return 0;
    } else if (temp.x_size == r1->x_size) {
      // 新矩形与原矩形的宽相等
      if (r1->y == temp.y)
        out->y += temp.y_size;
      out->y_size -= temp.y_size;
      return 1;
    } else if (temp.y_size == r1->y_size) {
      // 新矩形与原矩形的高相等
      if (r1->x == temp.x)
        out->x += temp.x_size;
      out->x_size -= temp.x_size;
      return 1;
    }
  }

  // 其他情况，结果不受影响
  return 1;
}

// 判断两个矩形相等，是返回1，不是返回0
int POS_RectEqual(RECT_Struct *r1, RECT_Struct *r2) {
  if (r1->x == r2->x && r1->y == r2->y && r1->x_size == r2->x_size &&
      r1->y_size == r2->y_size)
    return 1;
  else
    return 0;
}