package controllers

import (
    "database/sql"
    "encoding/json"
    "net/http"

    "github.com/gorilla/mux"
)

type Keyword struct {
    Id   int64  `bson:"_id"`
    Name string `json:keyword`
}

type Keywords []Keyword

// func getKeywords(w http.ResponseWriter, r *http.Request) {
//  db := dbConn()

//  selDB, err := db.Query("SELECT * FROM keywords")
//  checkErr(err)

//  kwd := Keyword{}

//  for selDB.Next() {
//      var uid int
//      var keyword string
//      err = selDB.Scan(&uid, &keyword)
//      checkErr(err)
//      kwd.Id = uid
//      kwd.Keyword = keyword
//  }

//  json.NewEncoder(w).Encode(map[string]Keyword{"keywords": kwd})

//  defer db.Close()
// }

func dbConn() (db *sql.DB) {
    dbDriver := "mysql"
    dbUser := "root"
    dbPass := ""
    dbName := "keywords"
    db, err := sql.Open(dbDriver, dbUser+":"+dbPass+"@/"+dbName)
    if err != nil {
        panic(err.Error())
    }
    return db
}

func (c Keyword) Add(w http.ResponseWriter, r *http.Request) {
    db := dbConn()

    if r.Method == "POST" {
        params := mux.Vars(r)
        kw := params["keyword"]

        sqlStatement := `SELECT id, keyword FROM keywords WHERE keyword=?;`
        var keyword string
        var id int
        // Replace 3 with an ID from your database or another random
        // value to test the no rows use case.
        row := db.QueryRow(sqlStatement, kw)

        switch err := row.Scan(&id, &keyword); err {
        case sql.ErrNoRows:
            insForm, err := db.Prepare("INSERT INTO keywords(keyword) VALUES(?)")
            if err != nil {
                panic(err.Error())
            }
            insForm.Exec(kw)

            json.NewEncoder(w).Encode("Added " + kw)
        case nil:
            json.NewEncoder(w).Encode(kw + " already exists.")
        default:
            panic(err)
        }
    }
    defer db.Close()
    http.Redirect(w, r, "/", 301)
}

func (c Keyword) GetAll(w http.ResponseWriter, r *http.Request) {
    db := dbConn()

    if r.Method == "GET" {

        rows, err := db.Query("SELECT id, keyword FROM keywords")
        if err != nil {
            // handle this error better than this
            panic(err)
        }

        jsonText := []byte(`[]`)

        var keywords []Keyword

        err1 := json.Unmarshal(jsonText, &keywords)

        if err1 != nil {
            // handle this error better than this
            panic(err1)
        }

        defer rows.Close()
        for rows.Next() {
            var id int64
            var keyword string
            err = rows.Scan(&id, &keyword)
            if err != nil {
                // handle this error
                panic(err)
            }

            keywords = append(keywords, Keyword{Id: id, Name: keyword})
        }

        result, err := json.Marshal(keywords)

        w.Write(result)

        // get any error encountered during iteration
        err = rows.Err()
        if err != nil {
            panic(err)
        }
    }
    defer db.Close()
}