package tests

import (
  "testing"
  "fmt"
  "reflect"
  "zedshaw.games/webapp/data"
  _ "github.com/mattn/go-sqlite3"
  sq "github.com/Masterminds/squirrel"
)

func SelectTable(table string, the_type reflect.Type) ([]reflect.Value, error) {
  var results []reflect.Value
  sql_query, args, err := sq.Select("*").From(table).ToSql()
  if err != nil { return results, err }

  rows, err := data.DB.Queryx(sql_query, args...)
  if err != nil { return results, err }
  defer rows.Close()

  for rows.Next() {
    the_data := reflect.New(the_type)
    err = rows.StructScan(the_data.Interface())
    if err != nil { return results, err }

    results = append(results, the_data.Elem())
  }

  return results, rows.Err()
}

func Get(table string, the_type reflect.Type, id int64) (reflect.Value, error) {
  sql_query, args, err := sq.Select("*").From(table).Where("id", id).ToSql()
  if err != nil { return reflect.New(nil), err }

  the_data := reflect.New(the_type)
  err = data.DB.Get(the_data.Interface(), sql_query, args...)

  // BUG: not sure if Elem or returning the reflect.New is better
  return the_data.Elem(), err
}

func Delete(table string, id int64) error {
  sql_query, args, err := sq.Delete(table).Where("id", id).ToSql()
  if err != nil { return err }

  _, err = data.DB.Exec(sql_query, args...)
  return err
}

func Update(table string, value reflect.Value) error {
  builder := sq.Update(table)

  type_of := value.Type()
  field_num := value.NumField()
  fmt.Printf("value has %d fields", field_num)

  for i := 0; i < field_num; i++ {
    field := value.Field(i)
    tag := type_of.Field(i).Tag.Get("db")

    // skip update of id to avoid replacing it
    if tag == "id" { continue }

    fmt.Printf("\nset %v to %v", tag, field.Interface())
    builder = builder.Set(tag, field.Interface())
  }

  builder.Where("id", value.FieldByName("Id").Interface())

  sql_query, args, err := builder.ToSql()

  fmt.Println("SQL: sql_query", sql_query, args, err)

  _, err = data.DB.Exec(sql_query, args...)

  return err
}

func TestAdminIndexPage(t *testing.T) {
  models := data.Models()
  table := "user"
  model := models[table]

  fmt.Printf("\n------\ntable=%s; model=%s\n", table, model.Name())
  fields := reflect.VisibleFields(model)

  for _, field := range fields {
    fmt.Println("\t", field.Name, field.Type, field.Tag)
  }

  all_rows, err := SelectTable(table, model)
  if err != nil { fmt.Println("ERROR", err) }
  first_row := all_rows[0]

  result, err := Get(table, model, first_row.FieldByName("Id").Int())
  if err != nil { fmt.Println("ERROR", err) }
  fmt.Println("TABLE: ", result)

  id := result.FieldByName("Id")
  result, err = Get(table, model, id.Int())
  if err != nil { fmt.Println("ERROR", err) }
  fmt.Println("GET: ", result)

  username := result.FieldByName("Username")

  username.SetString("joeblow")
  err = Update(table, result)
  if err != nil { fmt.Println("ERROR", err) }

  username.SetString("zedshaw")
  err = Update(table, result)
  if err != nil { fmt.Println("ERROR", err) }

  // err = Delete(table, id.Int())
  // if err != nil { fmt.Println("ERROR", err) }
}