package main

import (
        "database/sql"
        "encoding/json"
        "io/ioutil"
        "log"
        "net/http"
        "strconv"
        "strings"
        "structs"

        _ "github.com/go-sql-driver/mysql"
        "github.com/gorilla/mux"

        // "net/url"
        "fmt"
        //"os"
        //"io"
)

var categs, recipes = structs.InitAll()
var conf = structs.GetConfig()
var db, err = sql.Open("mysql", conf["login"]+":"+conf["password"]+"@/"+conf["dbname"])

func main() {

        if err != nil {
                fmt.Println(err)
        }
        defer db.Close()

        r := mux.NewRouter()

        r.HandleFunc("/", MainHandler)
        r.HandleFunc("/auth", AuthenticationHandler)
        r.HandleFunc("/register", RegisterHandler)
        r.HandleFunc("/filter", RecipesGetFiltredHandler)
        r.HandleFunc("/category/{id}", CategRecipeGetHandler)
        r.HandleFunc("/categories", CategoriesGetHandler)
        r.HandleFunc("/food", FoodGetHandler)
        r.HandleFunc("/food/{id}/allergen", AddAllergenHandler)
        r.HandleFunc("/food/{id}/delallergen", DelAllergenHandler)
        r.HandleFunc("/recipe/{id}/addtofav", AddToFavPostHandler)
        r.HandleFunc("/recipe/{id}/deletefromfav", DeleteFromFavHandler)
        r.HandleFunc("/recipe/{id}/comments", CommentsGetHandler)
        r.HandleFunc("/recipe/{id}/comment", CommentPostHandler)
        r.HandleFunc("/recipe/{id}", RecipeGetHandler)
        r.HandleFunc("/recipes", RecipesGetHandler)
        r.HandleFunc("/user/getfavs", FavsGetHandler)
        r.HandleFunc("/user/allergens", AllergensHandler)
        r.HandleFunc("/user/menu/{meal}", MenuGetHandler)
        r.HandleFunc("/user/menuadd/{meal}", MenuPostHandler)
        r.HandleFunc("/user/menudel/{meal}", DelMenuHandler)

        log.Println("Listen port " + conf["port"])
        http.ListenAndServe(":"+conf["port"], r)
}

func AllergensHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)

        body, err := ioutil.ReadAll(iReq.Body)

        if err != nil {
                fmt.Println(err)
        }

        var data map[string]string

        err = json.Unmarshal(body, &data)

        if err != nil {
                fmt.Println(err)
        }

        row := db.QueryRow("select id from "+conf["dbname"]+"."+conf["users"]+" where login = ?", data["login"])

        var uid int

        err = row.Scan(&uid)

        rows, err := db.Query("select ingredient_id from "+conf["dbname"]+"."+conf["allergens"]+" where user_id = ?", uid)

        if err != nil {
                fmt.Println(err)
        }

        var result []structs.ShortFoodForm

        for rows.Next() {
                rec := structs.ShortFoodForm{}

                var ingid int
                err = rows.Scan(&ingid)

                if err != nil {
                        fmt.Println(err)
                }

                meal := db.QueryRow("select id, name from "+conf["dbname"]+"."+conf["ingredients"]+" where id = ?", ingid)

                err = meal.Scan(&rec.Id, &rec.Name)

                if err != nil {
                        fmt.Println(err)
                }

                result = append(result, rec)
        }

        if len(result) == 0 {
                fmt.Println(err)
                iWrt.WriteHeader(http.StatusNotFound)
        } else {
                outJson, err := json.Marshal(result)

                if err != nil {
                        fmt.Println(err)
                }

                iWrt.Write(outJson)
        }
}

func DelMenuHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)

        vars := mux.Vars(iReq)

        body, err := ioutil.ReadAll(iReq.Body)

        if err != nil {
                fmt.Println(err)
        }

        var data map[string]string
        err = json.Unmarshal(body, &data)

        if err != nil {
                fmt.Println(err)
        }

        var uid, recid int

        mealtime := vars["meal"]
        day := data["day"]
        recid, err = strconv.Atoi(data["recipe_id"])

        if err != nil {
                fmt.Println(err)
        }

        row := db.QueryRow("select id from "+conf["dbname"]+"."+conf["users"]+" where login = ?", data["login"])

        err = row.Scan(&uid)

        if err != nil {
                fmt.Println(err)
        }

        _, err = db.Exec("delete from "+conf["dbname"]+"."+conf["recday"]+" where user_id = ? and recipe_id = ? and day = ? and mealtime = ?", uid, recid, day, mealtime)

        if err != nil {
                fmt.Println(err)
                iWrt.WriteHeader(http.StatusTeapot)
        } else {
                iWrt.WriteHeader(http.StatusOK)
        }

}

func DelAllergenHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)

        vars := mux.Vars(iReq)

        body, err := ioutil.ReadAll(iReq.Body)

        if err != nil {
                fmt.Println(err)
        }

        var data map[string]string

        err = json.Unmarshal(body, &data)

        if err != nil {
                fmt.Println(err)
        }

        var uid, allid int

        allid, err = strconv.Atoi(vars["id"])

        if err != nil {
                fmt.Println(err)
        }

        row := db.QueryRow("select id from "+conf["dbname"]+"."+conf["users"]+" where login = ?", data["login"])

        err = row.Scan(&uid)

        if err != nil {
                fmt.Println(err)
        }

        deleter, err := db.Prepare("delete from " + conf["dbname"] + "." + conf["allergens"] + " where user_id = ? and ingredient_id = ?")

        if err != nil {
                fmt.Println(err)
        }

        _, err = deleter.Exec(uid, allid)

        if err != nil {
                fmt.Println(err)
                iWrt.WriteHeader(http.StatusTeapot)
        } else {
                iWrt.WriteHeader(http.StatusOK)
        }
}

func AddAllergenHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)

        vars := mux.Vars(iReq)

        ingid, err := strconv.Atoi(vars["id"])

        if err != nil {
                fmt.Println(err)
        }

        body, err := ioutil.ReadAll(iReq.Body)

        if err != nil {
                fmt.Println(err)
        }

        var data map[string]string
        err = json.Unmarshal(body, &data)

        if err != nil {
                fmt.Println(err)
        }

        row := db.QueryRow("select id from "+conf["dbname"]+"."+conf["users"]+" where login = ?", data["login"])

        var uid int
        err = row.Scan(&uid)

        inserter, err := db.Prepare("insert into " + conf["dbname"] + "." + conf["allergens"] + " (ingredient_id, user_id) values(?, ?)")

        _, err = inserter.Exec(ingid, uid)

        if err != nil {
                fmt.Println(err)
                iWrt.WriteHeader(http.StatusTeapot)
        } else {
                iWrt.WriteHeader(http.StatusCreated)
        }
}

func FoodGetHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)

        var result []structs.ShortFoodForm

        rows, err := db.Query("select id, name from " + conf["dbname"] + "." + conf["ingredients"] + " order by name")

        if err != nil {
                fmt.Println(err)
        }

        for rows.Next() {
                rec := structs.ShortFoodForm{}

                err = rows.Scan(&rec.Id, &rec.Name)

                if err != nil {
                        fmt.Println(err)
                }

                result = append(result, rec)
        }

        if len(result) == 0 {
                iWrt.WriteHeader(http.StatusNotFound)
        } else {
                outJson, err := json.Marshal(result)

                if err != nil {
                        fmt.Println(err)
                }

                iWrt.Write(outJson)
        }
}

func DeleteFromFavHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)
        vars := mux.Vars(iReq)
        recid, err := strconv.Atoi(vars["id"])

        if err != nil {
                fmt.Println(err)
        }

        body, err := ioutil.ReadAll(iReq.Body)

        if err != nil {
                fmt.Println(err)
        }

        var data map[string]string
        err = json.Unmarshal(body, &data)

        if err != nil {
                fmt.Println(err)
        }

        row := db.QueryRow("select id from "+conf["dbname"]+"."+conf["users"]+" where login = ?", data["login"])

        var uid int
        err = row.Scan(&uid)

        if err != nil {
                fmt.Println(err)
        }

        deleter, err := db.Prepare("delete from " + conf["dbname"] + "." + conf["favs"] + " where recipe_id = ? and user_id = ?")

        if err != nil {
                fmt.Println(err)
        }

        _, err = deleter.Exec(recid, uid)

        if err != nil {
                fmt.Println(err)
                iWrt.WriteHeader(http.StatusTeapot)
        } else {
                iWrt.WriteHeader(http.StatusOK)
        }
}

func MenuPostHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)
        var data map[string]string

        vars := mux.Vars(iReq)

        body, err := ioutil.ReadAll(iReq.Body)

        if err != nil {
                fmt.Println(err)
        }

        err = json.Unmarshal(body, &data)

        if err != nil {
                fmt.Println(err)
        }

        fmt.Println(data)

        recid, err := strconv.Atoi(data["recipe_id"])

        if err != nil {
                fmt.Println(err)
        }

        row := db.QueryRow("select id from "+conf["dbname"]+"."+conf["users"]+" where login = ?", data["login"])

        var uid int
        err = row.Scan(&uid)

        if err != nil {
                fmt.Println(err)
        }

        _, err = db.Exec("insert into "+conf["dbname"]+"."+conf["recday"]+" (recipe_id, user_id, day, mealtime) values(?, ?, ?, ?)", recid, uid, data["day"], vars["meal"])

        if err != nil {
                fmt.Println(err)
                iWrt.WriteHeader(http.StatusTeapot)
        } else {
                iWrt.WriteHeader(http.StatusCreated)
        }
}

func FavsGetHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)
        body, err := ioutil.ReadAll(iReq.Body)

        if err != nil {
                fmt.Println(err)
        }

        var data map[string]string

        err = json.Unmarshal(body, &data)

        if err != nil {
                fmt.Println(err)
        }

        row := db.QueryRow("select id from "+conf["dbname"]+"."+conf["users"]+" where login = ?", data["login"])

        var uid int
        err = row.Scan(&uid)

        if err != nil {
                fmt.Println(err)
        }

        var result []structs.Frecipe

        rows, err := db.Query("select recipe_id from "+conf["dbname"]+"."+conf["favs"]+" where user_id = ?", uid)

        for rows.Next() {
                var rec_id int
                rec := structs.Frecipe{}
                err = rows.Scan(&rec_id)

                fmt.Println(rec_id)

                if err != nil {
                        fmt.Println(err)
                }

                recipe := db.QueryRow("select * from "+conf["dbname"]+"."+conf["recipes"]+" where id = ?", rec_id)

                err = recipe.Scan(&rec.Recipe_id, &rec.User_id, &rec.Recipe_title, &rec.Time_of_cooking, &rec.Recipe,
                        &rec.Recipe_image, &rec.Recipe_type, &rec.Calories, &rec.Proteins, &rec.Carbohydrates,
                        &rec.Portions, &rec.Fats, &rec.Recipe_ingredients)

                if err != nil {
                        fmt.Println(err)
                }

                result = append(result, rec)
        }

        if len(result) == 0 {
                iWrt.WriteHeader(http.StatusNotFound)
        } else {
                outJson, err := json.Marshal(result)

                if err != nil {
                        fmt.Println(err)
                }

                iWrt.Write(outJson)
        }
}

func MenuGetHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)

        var data map[string]string
        var result []structs.Frecipe

        vars := mux.Vars(iReq)

        body, err := ioutil.ReadAll(iReq.Body)

        if err != nil {
                fmt.Println(err)
        }

        err = json.Unmarshal(body, &data)

        if err != nil {
                fmt.Println(err)
        }

        row := db.QueryRow("select id from "+conf["dbname"]+"."+conf["users"]+" where login = ?", data["login"])

        fmt.Println("users")

        var uid int
        err = row.Scan(&uid)

        if err != nil {
                fmt.Println(err)
        }

        rows, err := db.Query("select recipe_id from "+conf["dbname"]+"."+conf["recday"]+" where user_id = ? and mealtime = ? and day = ?", uid, vars["meal"], data["day"])

        fmt.Println("recday")

        if err != nil {
                fmt.Println(err)
        }

        for rows.Next() {
                rec := structs.Frecipe{}

                var recid int
                err = rows.Scan(&recid)

                if err != nil {
                        fmt.Println(err)
                }

                recipe := db.QueryRow("select * from "+conf["dbname"]+"."+conf["recipes"]+" where id = ?", recid)

                fmt.Println("recipes")

                err = recipe.Scan(&rec.Recipe_id, &rec.User_id, &rec.Recipe_title, &rec.Time_of_cooking, &rec.Recipe,
                        &rec.Recipe_image, &rec.Recipe_type, &rec.Calories, &rec.Proteins, &rec.Carbohydrates,
                        &rec.Portions, &rec.Fats, &rec.Recipe_ingredients)

                if err != nil {
                        fmt.Println(err)
                }

                result = append(result, rec)
        }

        if len(result) == 0 {
                iWrt.WriteHeader(http.StatusNotFound)
        } else {
                outJson, err := json.Marshal(result)

                if err != nil {
                        fmt.Println(err)
                }

                iWrt.Write(outJson)
        }
}

func AddToFavPostHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)

        vars := mux.Vars(iReq)

        id, err := strconv.Atoi(vars["id"])

        if err != nil {
                fmt.Println(err)
        }

        var data map[string]string
        body, err := ioutil.ReadAll(iReq.Body)

        if err != nil {
                fmt.Println(err)
        }

        err = json.Unmarshal(body, &data)

        if err != nil {
                fmt.Println(err)
        }

        row := db.QueryRow("select id from "+conf["dbname"]+"."+conf["users"]+" where login = ?", data["login"])

        var uid int
        err = row.Scan(&uid)

        if err != nil {
                fmt.Println(err)
        }

        if uid == 0 {
                return
        }

        inserter, err := db.Prepare("insert into " + conf["dbname"] + "." + conf["favs"] + " (recipe_id, user_id) values(?, ?)")

        if err != nil {
                fmt.Println(err)
        }

        _, err = inserter.Exec(id, uid)

        if err != nil {
                fmt.Println(err)
                iWrt.WriteHeader(http.StatusTeapot)
        } else {
                iWrt.WriteHeader(http.StatusCreated)
        }
}

func AuthenticationHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)

        var data map[string]string
        body, err := ioutil.ReadAll(iReq.Body)

        if err != nil {
                fmt.Println(err)
        }

        err = json.Unmarshal(body, &data)

        fmt.Println(data)

        if err != nil {
                fmt.Println(err)
        }

        rows, err := db.Query("select * from "+conf["dbname"]+"."+conf["users"]+" where login = ? and password = ?", data["login"], data["password"])

        if rows.Next() {
                iWrt.WriteHeader(http.StatusOK)
        } else {
                iWrt.WriteHeader(http.StatusTeapot)
        }
}

func RegisterHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)

        var data map[string]string
        body, err := ioutil.ReadAll(iReq.Body)

        if err != nil {
                fmt.Println(err)
        }

        err = json.Unmarshal(body, &data)

        fmt.Println(data)

        if err != nil {
                fmt.Println(err)
        }

        rows, err := db.Query("select * from "+conf["dbname"]+"."+conf["users"]+" where login = ? or mail = ?",
                data["login"], data["mail"])

        if err != nil {
                fmt.Println(err)
        }

        acs := structs.AccessForm{}

        acs.Access = !rows.Next()

        if acs.Access {
                _, err = db.Exec("insert into "+conf["dbname"]+"."+conf["users"]+" (login, password, mail) values (?, ?, ?)",
                        data["login"], data["password"], data["mail"])
                iWrt.WriteHeader(http.StatusCreated)
        } else {
                iWrt.WriteHeader(http.StatusTeapot)
        }
}

func CommentsGetHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)

        vars := mux.Vars(iReq)
        recid, err := strconv.Atoi(vars["id"])

        if err != nil {
                fmt.Println(err)
        }

        var result []structs.PostForm

        rows, err := db.Query("select id, text from "+conf["dbname"]+"."+conf["comments"]+" where recipe_id = ?", recid)

        if err != nil {
                fmt.Println(err)
        }

        for rows.Next() {
                rec := structs.PostForm{}

                err = rows.Scan(&rec.Id, &rec.Text)
                rec.Recipe_id = recid

                result = append(result, rec)
        }

        if len(result) == 0 {
                iWrt.WriteHeader(http.StatusNotFound)
        } else {
                outJson, err := json.Marshal(result)

                if err != nil {
                        fmt.Println(err)
                }

                iWrt.Write(outJson)
        }
}

func RecipesGetFiltredHandler(iWrt http.ResponseWriter, iReq *http.Request) {

        fmt.Println(iReq)

        keys := iReq.URL.Query()

        body, err := ioutil.ReadAll(iReq.Body)

        if err != nil {
                fmt.Println(err)
        }

        var data map[string]string
        err = json.Unmarshal(body, &data)

        if err != nil {
                fmt.Println(err)
        }

        var result []structs.Frecipe
        user := db.QueryRow("select id from "+conf["dbname"]+"."+conf["users"]+" where login = ?", data["login"])
        var uid int

        err = user.Scan(&uid)

        if err != nil {
                fmt.Println(err)
        }

        allergenRecipes, err := db.Query("select ingredient_id from "+conf["dbname"]+"."+conf["allergens"]+" where user_id = ?", uid)

        if err != nil {
                fmt.Println(err)
        }

        var keywords []string

        for allergenRecipes.Next() {
                keyword := ""
                var kwid int

                err = allergenRecipes.Scan(&kwid)

                if err != nil {
                        fmt.Println(err)
                }

                allergen := db.QueryRow("select name from "+conf["dbname"]+"."+conf["ingredients"]+" where id = ?", kwid)
                err = allergen.Scan(&keyword)

                if err != nil {
                        fmt.Println(err)
                }

                keyl := 6

                fmt.Println(keyl)

                keyword = keyword[:keyl]

                fmt.Println("OK")

                keywords = append(keywords, keyword)
        }

        rows, err := db.Query("select * from "+conf["dbname"]+"."+conf["recipes"]+" where fats between ? and ? and proteins between ? and ? and carbohydrates between ? and ? and calories between ? and ?",
                keys["fats_min"][0],
                keys["fats_max"][0], keys["proteins_min"][0], keys["proteins_max"][0], keys["carbohyd_min"][0], keys["carbohyd_max"][0],
                keys["calories_min"][0], keys["calories_max"][0])

        if err != nil {
                fmt.Println("60")
                fmt.Println(err)
        }

        for rows.Next() {
                rec := structs.Frecipe{}

                err = rows.Scan(&rec.Recipe_id, &rec.User_id, &rec.Recipe_title, &rec.Time_of_cooking, &rec.Recipe,
                        &rec.Recipe_image, &rec.Recipe_type, &rec.Calories, &rec.Proteins, &rec.Carbohydrates,
                        &rec.Portions, &rec.Fats, &rec.Recipe_ingredients)

                if err != nil {
                        fmt.Println(err)
                }

                if strings.Contains(rec.Recipe_title, strings.ToLower(keys["name"][0])) {
                        if keys["allergens"][0] == "true" {
                                for i := 0; i < len(keywords); i++ {
                                        fmt.Println(keywords[i])

                                        if strings.Contains(strings.ToLower(rec.Recipe_ingredients), strings.ToLower(keywords[i])) {
                                                break
                                        }

                                        if (i + 1) == len(keywords) {
                                                result = append(result, rec)
                                        }
                                }
                        } else {
                                result = append(result, rec)
                        }
                }
        }

        if len(result) == 0 {
                iWrt.WriteHeader(http.StatusLocked)
        } else {
                outJson, err := json.Marshal(result)

                if err != nil {
                        fmt.Println("86")
                        fmt.Println(err)
                }

                iWrt.Write(outJson)
        }
}

func CommentPostHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)

        var resp structs.PostForm
        vars := mux.Vars(iReq)

        id, err := strconv.Atoi(vars["id"])

        if err != nil {
                panic(err)
        }

        body, err := ioutil.ReadAll(iReq.Body)

        if err != nil {
                panic(err)
        } else {
                err = json.Unmarshal(body, &resp)
                if err != nil {
                        panic(err)
                }
        }

        _, err = db.Exec("insert into "+conf["dbname"]+"."+conf["comments"]+" (id, text) values (?, ?)", id, resp.Text)

        if err != nil {
                panic(err)
        } else {
                iWrt.WriteHeader(http.StatusCreated)
        }
}

func RecipesGetHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)

        var result []structs.Frecipe

        rows, error := db.Query("select * from " + conf["dbname"] + "." + conf["recipes"])
        if error != nil {
                panic(error)
        }

        for rows.Next() {
                rec := structs.Frecipe{}
                err := rows.Scan(&rec.Recipe_id, &rec.User_id, &rec.Recipe_title, &rec.Time_of_cooking, &rec.Recipe,
                        &rec.Recipe_image, &rec.Recipe_type, &rec.Calories, &rec.Proteins, &rec.Carbohydrates,
                        &rec.Portions, &rec.Fats, &rec.Recipe_ingredients)
                if err != nil {
                        panic(err)
                }

                result = append(result, rec)

        }

        if len(result) == 0 {
                iWrt.WriteHeader(http.StatusNotFound)
        } else {
                outJson, err := json.Marshal(result)

                if err != nil {
                        panic(err)
                }

                iWrt.Write(outJson)
        }
}

func MainHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)
        iWrt.WriteHeader(http.StatusNotFound)
}

func RecipeGetHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)
        vars := mux.Vars(iReq)

        recid, err := strconv.Atoi(vars["id"])

        if err != nil {
                fmt.Println(err)
        }

        row := db.QueryRow("select * from "+conf["dbname"]+"."+conf["recipes"]+" where id = ?", recid)

        rec := structs.Frecipe{}

        err = row.Scan(&rec.Recipe_id, &rec.User_id, &rec.Recipe_title, &rec.Time_of_cooking, &rec.Recipe,
                &rec.Recipe_image, &rec.Recipe_type, &rec.Calories, &rec.Proteins, &rec.Carbohydrates,
                &rec.Portions, &rec.Fats, &rec.Recipe_ingredients)

        if err != nil {
                fmt.Println(err)
                iWrt.WriteHeader(http.StatusNotFound)
        } else {

                outJson, _ := json.Marshal(rec)
                iWrt.Write(outJson)
        }
}

func CategoriesGetHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        var result []structs.Categ

        rows, err := db.Query("select * from " + conf["dbname"] + "." + conf["recipes_types"])

        if err != nil {
                fmt.Println(err)
        }

        for rows.Next() {
                var categ = structs.Categ{}

                err = rows.Scan(&categ.Recipe_type, &categ.Type_name, &categ.Type_image)

                if err != nil {
                        fmt.Println(err)
                }

                result = append(result, categ)
        }

        if len(result) != 0 {
                outJson, _ := json.Marshal(result)
                iWrt.Write(outJson)
        } else {
                iWrt.WriteHeader(http.StatusNotFound)
        }
}

func CategRecipeGetHandler(iWrt http.ResponseWriter, iReq *http.Request) {
        fmt.Println(iReq)
        vars := mux.Vars(iReq)

        category, err := strconv.Atoi(vars["id"])

        if err != nil {
                panic(err)
        }

        var result []structs.Frecipe

        rows, err := db.Query("select * from "+conf["dbname"]+"."+conf["recipes"]+" where type_id = ?", category)

        if err != nil {
                panic(err)
        }

        for rows.Next() {
                rec := structs.Frecipe{}

                err = rows.Scan(&rec.Recipe_id, &rec.User_id, &rec.Recipe_title, &rec.Time_of_cooking, &rec.Recipe,
                        &rec.Recipe_image, &rec.Recipe_type, &rec.Calories, &rec.Proteins, &rec.Carbohydrates,
                        &rec.Portions, &rec.Fats, &rec.Recipe_ingredients)

                if err != nil {
                        panic(err)
                }

                result = append(result, rec)
        }

        if len(result) == 0 {
                iWrt.WriteHeader(http.StatusNotFound)
        } else {
                outJson, err := json.Marshal(result)

                if err != nil {
                        panic(err)
                }

                iWrt.Write(outJson)
        }
}