#include "../inc/swilib.h"
#include "color.h"
#include "string_util.h"
#include "lang.h"
#include "rect_patcher.h"
#include "conf_loader.h"

extern const char color_PATH[];
char * cur_color_name;

// Цвета

RGBA MAINBG_NOT_CONNECTED;
RGBA MAINBG_CONNECTED;
RGBA MAINBG_ERROR;
RGBA MAINFONT_NOT_CONNECTED = {200, 200, 200, 100};
RGBA MAINFONT_CONNECTED;
RGBA MAINFONT_ERROR;
RGBA MESSAGEWIN_BGCOLOR;
RGBA MESSAGEWIN_TITLE_BGCOLOR;
RGBA MESSAGEWIN_TITLE_FONT;
RGBA MESSAGEWIN_MY_BGCOLOR;
RGBA MESSAGEWIN_CH_BGCOLOR;
RGBA MESSAGEWIN_GCHAT_BGCOLOR_1;
RGBA MESSAGEWIN_CURSOR_BGCOLOR;
RGBA MESSAGEWIN_GCHAT_BGCOLOR_2;
RGBA MESSAGEWIN_SYS_BGCOLOR; 
RGBA MESSAGEWIN_STATUS_BGCOLOR; 
RGBA MESSAGEWIN_CHAT_FONT;
RGBA CURSOR;
RGBA CURSOR_BORDER;        
RGBA CLIST_F_COLOR_0;        
RGBA CLIST_F_COLOR_1;        
RGBA CONTACT_BG_0;         
RGBA CONTACT_BG_1;
RGBA lineColor;    
RGBA borderColor;
RGBA PRES_COLORS[PRES_COUNT];

/* 
  Инициализация цветов.
  В параметр нужно передать буффер конфига цветов
*/
RGBA Char4ToRGBA(const char in[4])
{
  RGBA result;
  result.r= in[0];
  result.g= in[1];
  result.b= in[2];
  result.a= in[3];
  return result;
}

void InitColor()
{
  extern const char CURSOR_c[];
  CURSOR = Char4ToRGBA(CURSOR_c);

  extern const char CURSOR_BORDER_c[];
  CURSOR_BORDER = Char4ToRGBA(CURSOR_BORDER_c);
  
  extern const char CLIST_F_COLOR_0_c[];
  CLIST_F_COLOR_0 = Char4ToRGBA(CLIST_F_COLOR_0_c);
  
  extern const char CLIST_F_COLOR_1_c[];
  CLIST_F_COLOR_1 = Char4ToRGBA(CLIST_F_COLOR_1_c);
  
  extern const char CONTACT_BG_0_c[];
  CONTACT_BG_0 = Char4ToRGBA(CONTACT_BG_0_c);
  
  extern const char CONTACT_BG_1_c[];
  CONTACT_BG_1 = Char4ToRGBA(CONTACT_BG_1_c);
  
//  extern const char lineColor_c[];
//  lineColor = Char4ToRGBA(lineColor_c);
  
//  extern const char borderColor_c[];
//  borderColor = Char4ToRGBA(borderColor_c);
  
  extern const char MAINBG_NOT_CONNECTED_c[];
  MAINBG_NOT_CONNECTED = Char4ToRGBA(MAINBG_NOT_CONNECTED_c);
  
  extern const char MAINBG_CONNECTED_c[];
  MAINBG_CONNECTED = Char4ToRGBA(MAINBG_CONNECTED_c);
  
  extern const char MAINBG_ERROR_c[];
  MAINBG_ERROR = Char4ToRGBA(MAINBG_ERROR_c);
  
  extern const char MAINFONT_CONNECTED_c[];
  MAINFONT_CONNECTED = Char4ToRGBA(MAINFONT_CONNECTED_c);
  
  extern const char MAINFONT_ERROR_c[];
  MAINFONT_ERROR = Char4ToRGBA(MAINFONT_ERROR_c);
  
  extern const char MESSAGEWIN_BGCOLOR_c[];
  MESSAGEWIN_BGCOLOR = Char4ToRGBA(MESSAGEWIN_BGCOLOR_c);
  
  extern const char MESSAGEWIN_CURSOR_BGCOLOR_c[];
  MESSAGEWIN_CURSOR_BGCOLOR = Char4ToRGBA(MESSAGEWIN_CURSOR_BGCOLOR_c);
  
  extern const char MESSAGEWIN_TITLE_BGCOLOR_c[];
  MESSAGEWIN_TITLE_BGCOLOR = Char4ToRGBA(MESSAGEWIN_TITLE_BGCOLOR_c);
  
  extern const char MESSAGEWIN_TITLE_FONT_c[];
  MESSAGEWIN_TITLE_FONT = Char4ToRGBA(MESSAGEWIN_TITLE_FONT_c);
  
  extern const char MESSAGEWIN_MY_BGCOLOR_c[];
  MESSAGEWIN_MY_BGCOLOR = Char4ToRGBA(MESSAGEWIN_MY_BGCOLOR_c);
  
  extern const char MESSAGEWIN_CH_BGCOLOR_c[];
  MESSAGEWIN_CH_BGCOLOR = Char4ToRGBA(MESSAGEWIN_CH_BGCOLOR_c);
  
  extern const char MESSAGEWIN_GCHAT_BGCOLOR_1_c[];
  MESSAGEWIN_GCHAT_BGCOLOR_1 = Char4ToRGBA(MESSAGEWIN_GCHAT_BGCOLOR_1_c);
  
  extern const char MESSAGEWIN_GCHAT_BGCOLOR_2_c[];
  MESSAGEWIN_GCHAT_BGCOLOR_2 = Char4ToRGBA(MESSAGEWIN_GCHAT_BGCOLOR_2_c);
  
  extern const char MESSAGEWIN_SYS_BGCOLOR_c[];
  MESSAGEWIN_SYS_BGCOLOR = Char4ToRGBA(MESSAGEWIN_SYS_BGCOLOR_c);
  
  extern const char MESSAGEWIN_STATUS_BGCOLOR_c[];
  MESSAGEWIN_STATUS_BGCOLOR = Char4ToRGBA(MESSAGEWIN_STATUS_BGCOLOR_c);
  
  extern const char MESSAGEWIN_CHAT_FONT_c[];
  MESSAGEWIN_CHAT_FONT = Char4ToRGBA(MESSAGEWIN_CHAT_FONT_c);
  
  extern const char OnlineColor_c[];
  PRES_COLORS[0] = Char4ToRGBA(OnlineColor_c);

  extern const char ChatColor_c[];
  PRES_COLORS[1] = Char4ToRGBA(ChatColor_c);

  extern const char AwayColor_c[];
  PRES_COLORS[2] = Char4ToRGBA(AwayColor_c);

  extern const char XAColor_c[];
  PRES_COLORS[3] = Char4ToRGBA(XAColor_c);

  extern const char DNDColor_c[];
  PRES_COLORS[4] = Char4ToRGBA(DNDColor_c);

  extern const char InvisibleColor_c[];
  PRES_COLORS[5] = Char4ToRGBA(InvisibleColor_c);

  extern const char OfflineColor_c[];
  PRES_COLORS[6] = Char4ToRGBA(OfflineColor_c);

  extern const char ErrorColor_c[];
  PRES_COLORS[7] = Char4ToRGBA(ErrorColor_c);

  extern const char SubscribeColor_c[];
  PRES_COLORS[8] = Char4ToRGBA(SubscribeColor_c);

  extern const char SubscribedColor_c[];
  PRES_COLORS[9] = Char4ToRGBA(SubscribedColor_c);

  extern const char UnsubscribeColor_c[];
  PRES_COLORS[10] = Char4ToRGBA(UnsubscribeColor_c);

  extern const char UnsubscribedColor_c[];
  PRES_COLORS[11] = Char4ToRGBA(UnsubscribedColor_c);
}

/* Меню выбора цветовой схемы */
typedef struct
{
  void * next;
  char cfgname[64];
  char fullpath[128];
}SEL_COLOR;

int select_color_menu_onkey(void *gui, GUI_MSG *msg)
{
  SEL_COLOR * sbtop = MenuGetUserPointer(gui);
  if (msg->keys==0x3D)
  {
    int i=GetCurMenuItem(gui);
    for (int n = 0; n != i; n ++)
      sbtop = sbtop->next;
    if (sbtop)
    {
      if (cur_color_name) mfree(cur_color_name);
      cur_color_name = (char *)malloc(32);
      strcpy(cur_color_name, sbtop->cfgname);
      if (InitColorSet(cur_color_name))
        return (1);
    }
  }
  if (msg->keys==0x18)
  {
    int i=GetCurMenuItem(gui);
    for (int n = 0; n != i; n ++)
      sbtop = sbtop->next;
    if (sbtop)
    {
      int len = strlen(sbtop->fullpath);
      WSHDR * ws = AllocWS(len + 4);
      str_2ws(ws, sbtop->fullpath, len);
      ExecuteFile(ws, 0, 0);
      FreeWS(ws);
    }
  }
  return (0);
}

void select_color_menu_ghook(void *gui, int cmd)
{
  SEL_COLOR *sbtop = MenuGetUserPointer(gui);
  if (cmd == TI_CMD_DESTROY)
  {
    while(sbtop)
    {
      SEL_COLOR *sb = sbtop;
      sbtop = sbtop->next;
      mfree(sb);
    }    
  }
  if (cmd == TI_CMD_CREATE)
  {
    int cur_it=0;
    SEL_COLOR *sb = sbtop;
    while(sb)
    {
      if(!strcmp(sb->cfgname, cur_color_name)) break;
      sb = sb->next;
      cur_it++;
    }
    SetCursorToMenuItem(gui,cur_it);
  }
  if (cmd == TI_CMD_FOCUS)
  {
    DisableIDLETMR();
  }
}

extern int icon_array[2];

void select_color_menu_iconhndl(void *gui, int cur_item, void *user_pointer)
{
  SEL_COLOR * sbtop = user_pointer;
  WSHDR * ws;
  void * item = AllocMenuItem(gui);
  for (int n = 0; n != cur_item; n ++)
    sbtop = sbtop->next;
  if (sbtop)
  {
    int len = strlen(sbtop->cfgname);
    ws = AllocMenuWS(gui, len + 4);
    str_2ws(ws, sbtop->cfgname, len);
    SetMenuItemIconArray(gui, item, icon_array + (strcmp(sbtop->cfgname, cur_color_name)?1:0));
  }
  else
  {
    ws = AllocMenuWS(gui, 10);
    ascii2ws(ws, "Error");
    SetMenuItemIconArray(gui, item, icon_array);
  }
  SetMenuItemText(gui, item, ws, cur_item);
}

int select_color_menu_softkeys[]={0,1,2};

SOFTKEY_DESC select_color_menu_sk[]=
{
  {0x0018,0x0000,(int)LG_EDIT},
  {0x0001,0x0000,(int)LG_BACK},
  {0x003D,0x0000,(int)LGP_DOIT_PIC}
};

SOFTKEYSTAB select_color_menu_skt=
{
  select_color_menu_sk,0
};

HEADER_DESC select_color_menu_header = {0, 0, 0, 0, NULL, (int)LG_COLOR, LGP_NULL};

MENU_DESC select_color_menu_struct=
{
  8, select_color_menu_onkey, select_color_menu_ghook, NULL,
  select_color_menu_softkeys,
  &select_color_menu_skt,
  0x11,
  select_color_menu_iconhndl,
  NULL,   //Items
  NULL,   //Procs
  0   //n
};

void ShowSelectColorMenu()
{
  unsigned int err;
  DIR_ENTRY de;
  SEL_COLOR *sbtop = NULL;
  SEL_COLOR *sb;
  int n_bcfg=0;
  char str[128];
  strcpy(str, color_PATH);
  strcat(str, "*.bcfg");
  if (FindFirstFile(&de, str, &err))
  {
    do
    {
      if (!(de.file_attr & FA_DIRECTORY))
      {
        sb = malloc(sizeof(SEL_COLOR));
        strcpy(sb->fullpath, color_PATH);
        strcat(sb->fullpath, de.file_name);
        strcpy(sb->cfgname, de.file_name);
        sb->cfgname[strlen(de.file_name) - 5] = NULL;
        sb->next = NULL;
        if (sbtop)
        {
          SEL_COLOR * sbr, * sbt;
          sbr = (SEL_COLOR *)&sbtop;
          sbt = sbtop;
          while(stricmp(sbt->cfgname, sb->cfgname) < 0)
          {
            sbr = sbt;
            sbt = sbt->next;
            if (!sbt) break;
          }
          sb->next = sbt;
          sbr->next = sb;
        }
        else
        {
          sbtop = sb;
        }
        n_bcfg++;
      }
    }
    while(FindNextFile(&de,&err));
  }
  FindClose(&de,&err);
  icon_array[0]=GetPicNByUnicodeSymbol(CBOX_CHECKED);
  icon_array[1]=GetPicNByUnicodeSymbol(CBOX_UNCHECKED);
  patch_header(&select_color_menu_header);
  CreateMenu(0, 0, &select_color_menu_struct, &select_color_menu_header, 0, n_bcfg, sbtop, 0);
}

int InitColorSet(const char *fname) //1 - удачно, 0 - неполучилось...
{
  extern const char color_PATH[];
  extern char * cur_color_name;
  int result = 0;
  char * color_file = (char *)malloc(strlen(color_PATH) + strlen(fname) + 16);
  strcpy(color_file, color_PATH);
  strcat(color_file, fname);
  strcat(color_file, ".bcfg");
  if (LoadColorSetData(color_file)<=0)
  {
    mfree(color_file);
    color_file = (char *)malloc(strlen(color_PATH) + 16);
    strcpy(color_file, color_PATH);
    strcat(color_file, "default.bcfg");
    if(LoadColorSetData(color_file)<=0)
    {
      if(SaveColorSetData(color_file))
      {
         if(LoadColorSetData(color_file)>0)
         {
           result = 1;
           ShowMSG(1,(int)"Create default color.");
         }
      };
    } else result = 1;
    if (cur_color_name) mfree(cur_color_name);
    cur_color_name = (char *)malloc(32);
    strcpy(cur_color_name, "default");
  } else result = 1;
  mfree(color_file);
  InitColor();
  return (result);
}
// EOL, EOF