/*
 * Created by PyramIDE.
 * User: フランスのトトロ 
 * Date: 31/12/2015
 * Time: 16:18
 * © Calexium 
 */

read hayamiki_lib/types/hayamiki.anubis
read tools/basis.anubis
read tools/streams.anubis
read system/string.anubis
read fields.anubis
read columns.anubis
read html.anubis
  
define List(String)
/** 
 */
  _generate_type
  (
    List(HK_Model_Column) columns,
    List(String)          so_far
  )=
  if columns is
  {
    []        then reverse(so_far),
    [h . t ]  then
      since h is hk_column(name, col_type, _, _),
      _generate_type(t, [ "    "+fill(to_Anubis_type(col_type), 12) + " " + name . so_far])
  }.

public define Maybe(One)
  generate_type
  (
    Stream    stream,
    HK_Table  table,
    Bool      use_densaku
  )=
  since table is hk_table(name, short_name, model, display),
  since model is hk_model(columns, constraints, show_string),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //if we use densaku for generating the type, we insert the read of that type after densaku generation
  if use_densaku then
    write_string(stream, 
       "\n\ntransmit types/generated/"+to_lower(type_name)+".anubis\n")   //read of the type declaration
  
  else
  
    //generate the type of the HK_Table that contain all components 
    if write_string(stream, 
       "\n\npublic type "+type_name+":\n  "+name+"\n  (\n"+   //head of the type declaration
       join(",\n",_generate_type(columns, []))+               //all components of the type
       "\n  ).\n") is                                         //end of declaration
    {
      failure     then  println("can't write type "+type_name); failure,
      success(_)  then  success(unique)
    }
.


define List(String)
/** 
 */
  _generate_get_default
  (
    List(HK_Model_Column) columns,
    List(String)          so_far
  )=
  if columns is
  {
    []        then reverse(so_far),
    [h . t ]  then
      since h is hk_column(name, col_type, _, _),
      _generate_get_default(t, [ to_Anubis_default(col_type) . so_far])
  }.
  
public define Maybe(One)
  generate_get_default
  (
    Stream    stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_model(columns, constraints, show_string),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\npublic define "+type_name+"\n  get_default_"+name+" =\n  "+name+"("+   //head of the definition
     join(", ",_generate_get_default(columns, []))+                       //all components of the type
     ").\n\n") is                                                           //end of the function
  {
    failure     then  println("can't write get_default "+type_name); failure,
    success(_)  then  success(unique)
  }.


public define Maybe(One)
  generate_columns_list
  (
    Stream    stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_model(columns, constraints, show_string),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\npublic define List(String)\n  "+name+"_columns =\n  ["+            //head of the definition
     join(",\n    ",enclose("\"", to_List_String(columns, false)))+   //all columns name wihtout id
     "  ].\n\n"+
     "public define String\n"+
     " "+name+"_select_fields = \""+join(", ",to_List_String(name, columns, true))+"\".\n\n") is                                                   //end of the list
  {
    failure     then  println("can't write generate_columns_list "+type_name); failure,
    success(_)  then  success(unique)
  }.


public define Maybe(One)
  generate_get_one
  (
    Stream    stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_model(columns, constraints, show_string),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\n"+
     //SQL query
//     "public define Maybe("+type_name+")\n"+
//     "  get_"+name+"\n"+
//     "  (\n"+
//     "    SQLite3DataBase  db,\n"+
//     "    String           idx\n"+
//     "  )=\n"+
//     "  if sql_query_timeout(db, \"SELECT "+join(", ", enclose("\\\"",to_List_String(columns, true)))+" FROM "+name+" WHERE id=\"+idx+\";\", [], \"get_"+name+"\") is\n"+
//     "  {\n"+
//     "    error(_)         then failure,\n"+
//     "    ok(_, cursor, _) then extract_"+name+"(cursor)\n"+
//     "  }.\n\n"+
     //SQL query
     "public define Maybe("+type_name+")\n"+
     "  get_mb_"+name+"\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "    String           idx\n"+
     "  )=\n"+
     "  get_"+name+"_by_clause(db, \" id  = \"+idx).\n\n"+
     
     "public define Maybe("+type_name+")\n"+
     "  get_mb_"+name+"\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "    Int              idx\n"+
     "  )=\n"+
     "  get_"+name+"_by_clause(db, \" id  = \"+to_decimal(idx)).\n\n"+
     
     "public define Maybe("+type_name+")\n"+
     "  get_mb_"+name+"\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "    DB_id            idx\n"+
     "  )=\n"+
     "  if idx is\n"+
     "  {\n"+
     "    none        then failure,\n"+
     "    db_id(_idx) then get_mb_"+name+"(db, _idx)\n"+
     "  }"+
     
     ".\n\n"+
     "public define "+type_name+"\n"+
     "  get_"+name+"\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "    DB_id            idx\n"+
     "  )=\n"+
     "  if idx is\n"+
     "  {\n"+
     "    none        then get_default_"+name+",\n"+
     "    db_id(_idx) then\n"+
     "      if get_"+name+"_by_clause(db, \" id  = \"+to_decimal(_idx)) is\n"+
     "      {\n"+
     "        failure    then get_default_"+name+",\n"+
     "        success(r) then r\n"+
     "      }\n"+
     "  }"+
     ".\n\n"     
     ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_get_one "+type_name); failure,
    success(_)  then  success(unique)
  }.

public define Maybe(One)
  generate_get_one_json
  (
    Stream    stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_model(columns, constraints, show_string),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\n"+
     //SQL query
"public define JsonValue\n"+
"  get_one_"+name+"_to_json\n"+
"  (\n"+
"    SQLite3DataBase db,\n"+
"    List(String)    columns,\n"+
"    Bool            resolve_fk,\n"+
"    DB_id           idx\n"+
"  )=\n"+
"  with final_columns = if length(columns) = 0 then [\"id\", \"__HK_SHOW_STRING__\". "+name+"_columns] else columns,\n"+
"  with error = json_object(map((String col_name) |-> json_member(col_name, json_null), final_columns)),\n"+
"\n"+
"  if idx is\n"+
"  {\n"+
"    none        then error,\n"+
"    db_id(_idx)  then\n"+
"      if get_all_"+name+"_by_clause(db, \"id=\"+to_decimal(_idx)) is\n"+
"      {\n"+
"        failure         then error,\n"+
"        success(cursor) then\n"+
//"            if length(columns) = 0 then\n"+
//"              if extract_"+name+"_cursor_to_json(db, cursor) is\n"+
//"              {\n"+
//"                failure          then error,\n"+
//"                success(result)  then result\n"+
//"              }\n"+
//"            else\n"+
"          if extract_"+name+"_cursor_to_json(db, make_json_extractor(db, final_columns, resolve_fk), cursor) is\n"+
"          {\n"+
"            failure          then error,\n"+
"            success(result)  then result\n"+
"          }\n"+
"      }\n"+
"  }\n"+
".\n\n"
     ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_get_one "+type_name); failure,
    success(_)  then  success(unique)
  }.
  
public define Maybe(One)
  generate_get_one_with_clause
  (
    Stream    stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_model(columns, constraints, show_string),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\n"+
     //SQL query
     "public define Maybe("+type_name+")\n"+
     "  get_"+name+"_by_clause\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "    String           clause\n"+
     "  )=\n"+
     "  if sql_query_timeout(db, \"SELECT "+join(", ", enclose("\\\"",to_List_String(columns, true)))+" FROM "+name+" WHERE \"+clause+\";\", [], \"get_"+name+"_by_clause\") is\n"+
     "  {\n"+
     "    error(_)         then failure,\n"+
     "    ok(_, cursor, _) then extract_"+name+"(cursor)\n"+
     "  }.\n\n"      
     ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_get_one_by_clause "+type_name); failure,
    success(_)  then  success(unique)
  }.
  
public define Maybe(One)
  generate_update
  (
    Stream          stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_model( columns, constraints, _),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\n"+
     //SQL query
     "public define Maybe(Int)\n"+
     "  update_"+name+"\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "    "+type_name+"    "+name+"\n"+
     "  )=\n"+
     "  if "+name+".id is\n"+
     "  {\n"+
     //INSERT SQL query
     "    none then\n"+
     "      if sql_query_timeout(db,\n"+
     "             \"INSERT INTO "+name+"\n"+
     insert_values(columns, "             ")+";\",\n"+
     generate_Bind_list(columns, name, "             ", true)+",\n"+
     "             \"update_"+name+" (INSERT)\") is\n"+
     "      {\n"+
     "        error(sql_error)  then\n"+
     "          //logError(debug_log, db_error(sql_error, table_name));\n"+
     "          failure,\n"+
     "        ok(_, cursor, _)  then\n"+
     "          if sql_query_scalar(db, \"SELECT last_insert_rowid()\") is\n"+
     "          {\n"+
     "            error(_)  then  failure,\n"+
     "            ok(datum) then\n"+
     "              with r = if datum is integer(n) then n else 0,\n"+
     "              success(r)\n"+
     "          }\n"+
     "       },\n"+
     //UPDATE SQL query
     "    db_id(idx) then\n"+
     "      if sql_query_timeout(db,\n"+
     "             \"UPDATE "+name+" SET\n"+
     update_values(columns, "             ")+"\n"+
     "             WHERE id = \"+idx+\";\",\n"+
     generate_Bind_list(columns, name, "             ", false)+",\n"+
     "             \"update_"+name+" (UPDATE)\") is { \n"+
     "                 error(sql_error) then\n"+
     "                   logError(debug_log, db_error(sql_error, \"update_"+name+"\")); failure,\n"+
     "                 ok(_, _, _)      then success(idx) }\n"+
     "  }.\n\n"+
     
//     "public define Maybe(One)\n"+
//     "  update_"+name+"\n"+
//     "  (\n"+
//     "    SQLite3DataBase             db,\n"+
//     "    DB_id                       db_id,\n"+
//     "    List(SQLite3_update_field)  fields\n"+
//     "  )=\n"+
//     "  if db_id is\n"+
//     "  {\n"+
//     //INSERT SQL query
//     "    none then\n"+
//     "      since make_insert_clause_and_binds(fields) is (binds, insert_columns, insert_values),\n"+
//     "      if sql_query_timeout(db, \"INSERT INTO "+name+" \"+insert_columns+\" VALUES \"+insert_values+\";\", binds, \"update_"+name+" (INSERT)\") is\n"+
//     "      {\n"+
//     "        error(sql_error)  then logError(debug_log, db_error(sql_error, \"update_"+name+"\"));failure,\n"+
//     "        ok(_, _, _)       then success(unique)\n"+
//     "      },\n"+
//     //UPDATE SQL query
//     "    db_id(idx) then\n"+
//     "      since make_update_clause_and_binds(fields) is (binds, set_string),\n"+
//     "      if sql_query_timeout(db, \"UPDATE "+name+" SET \"+set_string +\" WHERE id = \"+idx+\";\", binds, \"update_"+name+" (UPDATE)\") is\n"+
//     "      {\n"+
//     "        error(sql_error) then logError(debug_log, db_error(sql_error, \"update_"+name+"\"));failure,\n"+
//     "        ok(_, _, _)      then success(unique)\n"+
//     "      }\n"+
//     "  }.\n\n"+
     
     "public define Maybe(Int)\n"+
     "  update_"+name+"_from_type\n"+
     "  (\n"+
     "    SQLite3DataBase db,\n"+
     "    List(Web_arg)   lwa\n"+
     "  )=\n"+
     "  if extract_"+type_name+"_from_web_arg(lwa, \"\") is\n"+
     "  {\n"+
     "    failure         then logError(debug_log, \"update_"+name+" extract_"+type_name+"_from_web_arg is failure\"); failure,\n"+
     "    success("+name+")  then update_"+name+"(db, "+name+")\n"+
     "  }.\n\n"+
     
     "public define Maybe(Int)\n"+
     "  update_"+name+"_from_fields\n"+
     "  (\n"+
     "    SQLite3DataBase db,\n"+
     "    List(Web_arg)   lwa\n"+
     "  )=\n"+
     "  insert_or_update(db, \""+name+"\", get_DB_id(lwa, \"id\"), extract_"+type_name+"_update_fields_from_web_arg(lwa, \"\"))\n"+
     ".\n\n"
  
     ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_update "+type_name); failure,
    success(_)  then  success(unique)
  }.

public define Maybe(One)
  generate_show_string
  (
    Stream    stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_model( columns, constraints, show_string),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\n"+
     //SQL query
     "public define String\n"+
     "  get_"+name+"_show_string\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "    DB_id            _idx\n"+
     "  )=\n"+
     "  if _idx is \n"+
     "  {\n"+
     "    none        then default_select,\n"+
     "    db_id(idx)  then \n"+
     "      if get_mb_"+name+"(db, idx) is\n"+
     "      {\n"+
     "        failure      then default_select,\n"+
     "        success(obj) then "+show_string+"\n"+
     "      }\n"+
     "  }."
     ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_update "+type_name); failure,
    success(_)  then  success(unique)
  }.

public define Maybe(One)
  generate_selector
  (
    Stream    stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_model( columns, constraints, show_string),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
    "\n\n"+
    "define List((List(CoreAttrs), WebArgValue, String))\n"+
    "  _get_selector_"+name+"\n"+
    "  (\n"+
    "    SQLite3DataBase             db,\n"+
    "    List("+type_name+")         list,\n"+
    "    List((List(CoreAttrs), WebArgValue, String))  so_far\n"+
    "  )=\n"+
    "  if list is\n"+
    "  {\n"+
    "    []        then  [selector_default_entry . reverse(so_far)],\n"+
    "    [ h . t ] then \n"+
    "      if h.id is \n"+
    "      {\n"+
    "        none      then [selector_default_entry],\n"+
    "        db_id(_id) then _get_selector_"+name+"(db, t, [([], wav(to_String(_id)), get_"+name+"_show_string(db, h.id)) . so_far])\n"+
    "      }\n"+
    "  }.\n\n"+
    "public define List((List(CoreAttrs), WebArgValue, String))\n"+
    "  get_selector_"+name+"\n"+
    "  (\n"+
    "    SQLite3DataBase  db,\n"+
    "    HK_Referer       referer,\n"+
    "    String           filter\n"+
    "  )=\n"+
    "  with clause = referer_to_sql_clause(referer, \""+name+"\", "+name+"_columns),\n\n"+
    "  with _and_ = if length(clause) > 0 & length(filter) > 0 then \" AND \" else \"\",\n"+
    "  _get_selector_"+name+"(db, get_all_"+name+"_by_clause_to_list_type(db, clause+_and_+filter), [])."
     ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_show_string "+type_name); failure,
    success(_)  then  success(unique)
  }.