package main

import (
	"net/http"
	"html/template"
"fmt"
   "database/sql"
   _ "github.com/go-sql-driver/mysql"
   "time"
)
type komunikat struct{
    Opis string
}

type Plan struct{
	Serie int
    Powtorzenia int
    Nazwa string
    Ciezar int
    Opis string
    data_t string
}
type Cwiczenie struct{
	Opis string 
	Rodzaj string
	Nazwa string
	Zdjecie string
}
type CwiczenieTabela struct{
    Id_cwiczenie int
    Nazwa string
   
}
type Wyniki struct{
    Ciezar_rzecz int
    Ciezar_cel int 
    Nazwa  string
        Data_t string
}
type ww struct{
    Wyniki []Wyniki 
    Nazwa  string
    NumerCwiczenia int
    Ilosc_cwiczen int
}
type Zmiany struct{
   co_ile_ciezar int
    ciezar_dodaj int
    co_ile_powtorzen int
    ciezar_powtorzen int
}
type Uzytkownicy struct {
    Url string
  Login string
  Haslo string
}

 type Cookie struct {
        Name       string
        Value      int
        Path       string
        Domain     string
        Expires    time.Time
        RawExpires string
        MaxAge   int
        Secure   bool
        HttpOnly bool
        Raw      string
        Unparsed []string 
    }
//deklaracja tmpl-POCZATEK
var tmpl2 = template.Must(template.ParseGlob("planowanieTreningu.html"))
var tmpl3 = template.Must(template.ParseGlob("cwiczenie.html"))
var tmpl4 = template.Must(template.ParseGlob("wyniki.html"))
var tmpl = template.Must(template.ParseGlob("koszyk.html"))
//deklaracja tmpl-KONIEC



//deklaracja funkcji-POCZATEK
func baza(){
    db, err := sql.Open("mysql", "finley:password@tcp(127.0.0.1:3306)/baza")
    if err != nil {
    panic(err.Error())
    }
    defer db.Close()
}


func getCookie(w http.ResponseWriter, r *http.Request) string {
 var decyzja   string
   c1, err := r.Cookie("logowanie")
    if err != nil {
    decyzja="brak"
    }else{
    decyzja=c1.Value
    }
   return decyzja 
}



func setCookie(w http.ResponseWriter, r *http.Request, id_uzytkownik string) {
fmt.Println("tt")
expiration := time.Now().Add(2 * time.Hour)
c1 := http.Cookie{Name: "logowanie", Value: id_uzytkownik, Expires: expiration}
fmt.Println(c1)
http.SetCookie(w, &c1)
}

//deklaracja funkcji-KONIEC


func planowanieTreningu(w http.ResponseWriter, r *http.Request) {

if getCookie(w,r)=="brak" {
    p := Plan{Opis: "zakładka"}
    t, _ := template.ParseFiles("brakdostepu.html")
    t.Execute(w, p)
    }else{

db, err := sql.Open("mysql", "finley:password@tcp(127.0.0.1:3306)/baza")
if err != nil {
panic(err.Error())
}
defer db.Close()

rows, err := db.Query("select nazwa from baza.cwiczenie")
     emp := Plan{}
    res := []Plan{}
    for rows.Next() {
          var nazwa string  
err = rows.Scan(&nazwa) 
        if err != nil {
            panic(err.Error()) 
        }
emp.Nazwa = nazwa
  res = append(res, emp)
    }





 if r.Method == "POST" {


 	//dodawanie rodzaju treningu oraz co ile powiekszać cieżar-POCZATEK
 	var co_ile_ciezar string
 	co_ile_ciezar="k"
co_ile_ciezar = r.FormValue("co_ile_ciezar")
ciezar_dodaj := r.FormValue("ciezar_dodaj")
co_ile_powtorzenie := r.FormValue("co_ile_powtorzenie")
powtorzenie_dodaj := r.FormValue("powtorzenie_dodaj")
rodzaj_treningu := r.FormValue("rodzaj_treningu")
fmt.Println(co_ile_ciezar)
fmt.Println(ciezar_dodaj)
fmt.Println(powtorzenie_dodaj)
fmt.Println(co_ile_powtorzenie)
fmt.Println(rodzaj_treningu)
if co_ile_ciezar!="" || ciezar_dodaj!="" || powtorzenie_dodaj!="" || co_ile_powtorzenie!="" {
	rows, err := db.Query("INSERT INTO baza.zmiany (ciezar_dodaj, powtorzenie_dodaj, co_ile_ciezar, co_ile_powtorzenie, id_uzytkownik, rodzaj_treningu) VALUES (?, ?, ?, ?,?, ?)", ciezar_dodaj, powtorzenie_dodaj, co_ile_ciezar, co_ile_powtorzenie,  getCookie(w,r), rodzaj_treningu)
if err != nil {panic(err.Error())}
defer rows.Close()

}


Powtorzenia := r.FormValue("Powtorzenia")
Ciezar := r.FormValue("Ciezar")
Serie := r.FormValue("Serie")
Nazwa := r.FormValue("Nazwa")
fmt.Println(Nazwa)
fmt.Println(Serie)
fmt.Println(Ciezar)
fmt.Println(Powtorzenia)
db, err := sql.Open("mysql", "finley:password@tcp(127.0.0.1:3306)/baza")
   
    if err != nil {
        panic(err.Error())
    }
  
    defer db.Close()



fmt.Println(Nazwa)
rows1, err:= db.Query("SELECT COUNT(*) FROM baza.trening_cel as a, baza.cwiczenie as b WHERE a.id_cwiczenie=b.id_cwiczenie and b.nazwa=? and a.id_uzytkownik=?", Nazwa, getCookie(w,r))
var liczba string 
for rows1.Next() { 
err = rows1.Scan(&liczba)
}
fmt.Println(liczba)
fmt.Println(rows1)
if liczba=="0"{
 fmt.Println("jeszcze nie") 

rows, err := db.Query("SELECT id_cwiczenie FROM baza.cwiczenie WHERE nazwa=?", Nazwa)
if err != nil {panic(err.Error())}

for rows.Next() {
emp := CwiczenieTabela{}
var id_cwiczenie int  
err = rows.Scan(&id_cwiczenie)
emp.Id_cwiczenie = id_cwiczenie
fmt.Println("jjjjj")
rows, err := db.Query("INSERT INTO trening_cel (id_cwiczenie, id_uzytkownik, powtorzenia, ciezar,serie) VALUES (?, ?, ?, ?, ? )", id_cwiczenie,getCookie(w,r), Powtorzenia, Ciezar, Serie)
if err != nil {
panic(err.Error())
}
    defer rows.Close()

}
}else{
    p := Plan{Opis: "zakładka"}
    t, _ := template.ParseFiles("komunikat.html")
    t.Execute(w, p)
 fmt.Println("to ćwiczenie już dodałeś")   
}
}
tmpl2.ExecuteTemplate(w, "Index", res)

}}



func wypiszHandler(w http.ResponseWriter, r *http.Request) {
//otwieranie bazy-POCZATEK
db, err := sql.Open("mysql", "finley:password@tcp(127.0.0.1:3306)/baza")
if err != nil {panic(err.Error())}
defer db.Close()
//otwieranie bazy-KONIEC 



//autoryzacja-POCZATEK
if getCookie(w,r)=="brak" {
    p := Plan{Opis: "zakładka"}
    t, _ := template.ParseFiles("brakdostepu.html")
    t.Execute(w, p)
    }else{


//sprawdzanie metody POST - POCZATEK
if r.Method == "POST" {
Powtorzenia := r.FormValue("Powtorzenia")
Ciezar := r.FormValue("Ciezar")
Serie := r.FormValue("Serie")
Nazwa := r.FormValue("Nazwa")
Akcja := r.FormValue("Akcja")
fmt.Println(Akcja)
fmt.Println(Ciezar)
currentTime := time.Now()
data_t:= currentTime.Format("2006-01-02")



//sprawdzanie czy dodano juz dzisiaj to cwiczenie-POCZATEK
rows1, err := db.Query("SELECT COUNT(*) FROM baza.trening_rzeczywisty as a, baza.cwiczenie as b WHERE a.id_cwiczenia=b.id_cwiczenie and  b.nazwa=? and a.id_uzytkownik=?  and a.data_t=?", Nazwa,getCookie(w,r),  data_t)
if err != nil {panic(err.Error())}
defer rows1.Close()
var liczba string 
for rows1.Next() { 
err = rows1.Scan(&liczba)
}


rows, err := db.Query("SELECT id_cwiczenie FROM baza.cwiczenie WHERE nazwa=?", Nazwa)
if err != nil {panic(err.Error())}
defer rows.Close()
for rows.Next() {
emp := CwiczenieTabela{}
var id_cwiczenie int  
err = rows.Scan(&id_cwiczenie)
emp.Id_cwiczenie = id_cwiczenie

if Akcja=="usun"{
fmt.Println("klik ut")
rows, err := db.Query("DELETE FROM baza.trening_cel where id_cwiczenie=? and id_uzytkownik=?", id_cwiczenie, getCookie(w,r))
if err != nil {panic(err.Error())}
defer rows.Close()
}


if Akcja=="zatwierdz" && liczba=="0"{
fmt.Println("klik zat")	
rows, err := db.Query("INSERT INTO trening_rzeczywisty (id_cwiczenia, id_uzytkownik, powtorzenia, ciezar,serie, data_t) VALUES (?, ?, ?, ?, ?, ? )", id_cwiczenie,getCookie(w,r), Powtorzenia, Ciezar, Serie, data_t)
if err != nil {panic(err.Error())}
defer rows.Close()

}else{
    p := Plan{Opis: "zakładka"}
    t, _ := template.ParseFiles("komunikat.html")
    t.Execute(w, p)
 fmt.Println("to ćwiczenie już dodałeś")   

//sprawdzanie czy dodano juz dzisiaj to cwiczenie-KONIEC
}
//sprawdzanie metody POST - KONIEC
}
}




//dodawanie  ciezaru lub powtórzenia zależnie od ilości treningów-POCZATEK
rows5, err := db.Query("SELECT ciezar_dodaj, powtorzenie_dodaj, co_ile_ciezar, co_ile_powtorzenie FROM baza.zmiany where id_uzytkownik=5")
if err != nil {panic(err.Error())}

for rows5.Next() {    
var ciezar_dodaj int
var powtorzenie_dodaj int
var co_ile_ciezar int
var co_ile_powtorzenie int   
err = rows5.Scan(&ciezar_dodaj, &powtorzenie_dodaj, &co_ile_ciezar, &co_ile_powtorzenie)
if err != nil {panic(err.Error())}

rows1, err := db.Query("SELECT P.nazwa, N.ciezar, N.powtorzenia FROM baza.trening_cel AS N, baza.cwiczenie AS P WHERE P.id_cwiczenie = N.id_cwiczenie and N.id_uzytkownik=?", getCookie(w,r))
if err != nil {panic(err.Error())}

for rows1.Next() {    
var nazwa string 
var ciezar int 
var powtorzenia int 
err = rows1.Scan(&nazwa, &ciezar, &powtorzenia)
if err != nil {panic(err.Error())}


rows3, err := db.Query("SELECT COUNT(*) from baza.trening_rzeczywisty as a, baza.cwiczenie as b where b.nazwa=? and a.id_uzytkownik=?", nazwa,getCookie(w,r))
if err != nil {panic(err.Error())}

for rows3.Next() {    
var liczba_treningow int 
err = rows3.Scan(&liczba_treningow)
if err != nil {panic(err.Error())}


//sprawdzanie czy dodac ciezar lub powtorzenie-POCZATEK
if liczba_treningow%co_ile_ciezar==0 || liczba_treningow%co_ile_powtorzenie==0{
ciezar=ciezar+ciezar_dodaj
powtorzenia=powtorzenia+powtorzenie_dodaj
rows3, err := db.Query("UPDATE baza.trening_cel as a, baza.cwiczenie as b SET a.ciezar=? WHERE a.id_uzytkownik=? and b.nazwa=? and a.id_cwiczenie=b.id_cwiczenie", ciezar,getCookie(w,r), nazwa)
if err != nil {panic(err.Error())}
fmt.Println(rows3)
}
//sprawdzanie czy dodac ciezar lub powtorzenie-KONIEC

}
//dodawanie  ciezaru lub powtórzenia zależnie od ilości treningów-KONIEC
}

}

rows, err := db.Query("SELECT N.serie, N.powtorzenia, P.nazwa, N.ciezar FROM trening_cel AS N, cwiczenie AS P WHERE P.id_cwiczenie = N.id_cwiczenie and id_uzytkownik like ?", getCookie(w,r))
if err != nil {panic(err.Error())}

emp := Plan{}
res := []Plan{}
for rows.Next() {
var serie int
var powtorzenia int
var nazwa string
var ciezar int   
err = rows.Scan(&serie, &powtorzenia, &nazwa, &ciezar)
if err != nil {panic(err.Error())}

emp.Serie = serie 
emp.Powtorzenia = powtorzenia
emp.Nazwa = nazwa
emp.Ciezar = ciezar
res = append(res, emp)
}
tmpl.ExecuteTemplate(w, "Index", res)
}
//autoryzacja-KONIEC
}


func logowanieHandler(w http.ResponseWriter, r *http.Request) {
    db, err := sql.Open("mysql", "finley:password@tcp(127.0.0.1:3306)/baza")
    if err != nil {
    panic(err.Error())
    }
    defer db.Close()



if r.Method == "GET" {
id_uzytkownik := r.FormValue("cookies")
setCookie(w, r, id_uzytkownik)
  p := Uzytkownicy{Url: "/logowanie"}
    t, _ := template.ParseFiles("logowanie.html")
    t.Execute(w, p)
}


if r.Method == "POST" {
Login := r.FormValue("Login")
Haslo := r.FormValue("Haslo")
   
   rows, err := db.Query("SELECT COUNT(*) FROM baza.uzytkownicy WHERE login=? and haslo=?", Login, Haslo)
 
    fmt.Println("2")

    if err != nil {
        panic(err.Error())
    }
     fmt.Println("2")
    for rows.Next() {
    var autoryzacja int 
    err = rows.Scan(&autoryzacja)

    if err != nil {
       panic(err.Error()) 
     }

    if autoryzacja!=0{


          rows, err := db.Query("SELECT id_uzytkownik FROM baza.uzytkownicy WHERE login=? and haslo=?", Login, Haslo)
 
    fmt.Println("2")

    if err != nil {
        panic(err.Error())
    }
     fmt.Println("2")
    for rows.Next() {
    var id_uzytkownik string 
    err = rows.Scan(&id_uzytkownik)

    if err != nil {
       panic(err.Error()) 
     }
    setCookie(w, r, id_uzytkownik)
    p := Uzytkownicy{Url: "/start"}
    t, _ := template.ParseFiles("start.html")
    t.Execute(w, p)}
    fmt.Println("1")

}else{
    fmt.Println("2")
    p := Uzytkownicy{Url: "/logowanie"}
    t, _ := template.ParseFiles("logowanie.html")
    t.Execute(w, p)

}}
}
fmt.Println(r.Method)
}






func opisCwiczenia(w http.ResponseWriter, r *http.Request) {
if getCookie(w,r)=="brak" {
    p := Plan{Opis: "zakładka"}
    t, _ := template.ParseFiles("brakdostepu.html")
    t.Execute(w, p)
}else{

//wyświetlanie treningu
nazwa := r.FormValue("Nazwa")
db, err := sql.Open("mysql", "finley:password@tcp(127.0.0.1:3306)/baza")
   
    if err != nil {
        panic(err.Error())
    }
  
    defer db.Close()

   rows, err := db.Query("SELECT opis, rodzaj, zdjecie FROM baza.cwiczenie where nazwa=?", nazwa)

    if err != nil {
        panic(err.Error())
    }


 emp := Cwiczenie{}
    res := []Cwiczenie{}
    for rows.Next() {
        var opis string
            var rodzaj string
     var zdjecie string
err = rows.Scan(&opis, &rodzaj, &zdjecie)
       //err = rows.Scan(&serie, &ciezar)
      
        if err != nil {
            panic(err.Error()) 
        }

emp.Opis = opis
emp.Rodzaj = rodzaj
emp.Zdjecie =zdjecie
emp.Nazwa =nazwa
  res = append(res, emp)
    }
    tmpl3.ExecuteTemplate(w, "Index", res)
//koniec wyświetlanie trenngu
}}

func wynikiHandler(w http.ResponseWriter, r *http.Request) {
    if getCookie(w,r)=="brak" {
    p := Plan{Opis: "zakładka"}
    t, _ := template.ParseFiles("brakdostepu.html")
    t.Execute(w, p)

    }else{
  db, err := sql.Open("mysql", "finley:password@tcp(127.0.0.1:3306)/baza")
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()
var Ilosc_cwiczen int
   rows4, err := db.Query("SELECT COUNT(*) from baza.trening_cel where id_uzytkownik=?",getCookie(w,r))
    if err != nil {
        panic(err.Error())
    }
 for rows4.Next() {
err = rows4.Scan(&Ilosc_cwiczen)  
        if err != nil {
            panic(err.Error()) 
        }
}
fmt.Println(Ilosc_cwiczen)
for i := 1; i < Ilosc_cwiczen+1; i++ {  
rows, err := db.Query("SELECT C.nazwa FROM baza.trening_cel AS N, baza.trening_rzeczywisty AS P, baza.cwiczenie AS C WHERE N.id = ? and C.id_cwiczenie = P.id_cwiczenia and C.id_cwiczenie =  N.id_cwiczenie",i)

    if err != nil {
        panic(err.Error())
    }

 emp := ww{}
 res := []ww{}
    for rows.Next() {
var nazwa string
       err = rows.Scan(&nazwa)
        if err != nil {
            panic(err.Error()) 
        }
       emp.Nazwa=nazwa
       emp.NumerCwiczenia=i


rows2, err := db.Query("SELECT P.ciezar, N.ciezar, P.data_t FROM baza.trening_cel AS N, baza.trening_rzeczywisty AS P, baza.cwiczenie AS C WHERE N.id = ? and C.id_cwiczenie = P.id_cwiczenia and C.id_cwiczenie =  N.id_cwiczenie",i)

    if err != nil {
        panic(err.Error())
    }
emp2 := Wyniki{}
res2 := []Wyniki{}
for rows2.Next() {
        var ciezar_rzecz int
        var ciezar_cel int
        var data_t string

       err = rows2.Scan(&ciezar_rzecz, &ciezar_cel, &data_t)
        if err != nil {
            panic(err.Error()) 
        }
        emp2.Ciezar_rzecz = ciezar_rzecz
        emp2.Ciezar_cel = ciezar_cel
        emp2.Data_t = data_t
        res2 = append(res2, emp2)
        }
        emp.Wyniki=res2



        }
res = append(res, emp)
tmpl4.ExecuteTemplate(w, "Index", res)
}
    }
  
}


func dodaj_cwiczenieHandler(w http.ResponseWriter, r *http.Request) {
  db, err := sql.Open("mysql", "finley:password@tcp(127.0.0.1:3306)/baza")
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()

if getCookie(w,r)=="brak" {
    p := Plan{Opis: "zakładka"}
    t, _ := template.ParseFiles("brakdostepu.html")
    t.Execute(w, p)

    }else{

 if r.Method == "POST" {
 	Nazwa := r.FormValue("Nazwa")

Rodzaj := r.FormValue("Rodzaj")
Opis := r.FormValue("Opis")
Zdjecie := r.FormValue("Zdjecie")


 fmt.Println(Nazwa)
  fmt.Println(Rodzaj)
   fmt.Println(Opis)
    fmt.Println(Zdjecie)

// insert, err := db.Query("INSERT INTO cwiczenie (opis, rodzaj, nazwa, zdjecie) VALUES (?,?,?,?)", Opis, Rodzaj, Nazwa, Zdjecie)
 insert, err := db.Query("INSERT INTO  baza.cwiczenie ( opis, rodzaj, nazwa, zdjecie)  VALUES ( ?,?,?,? )",Opis, Rodzaj, Nazwa, Zdjecie)
 // if err != nil {
 //        panic(err.Error())
 //    }
 //    defer insert.Close()
fmt.Println(insert)
fmt.Println(err)
}
p := Plan{Opis: "zakładka"}
	t, _ := template.ParseFiles("dodajcwiczenie.html")
	t.Execute(w, p)

}}



func rejestracja(w http.ResponseWriter, r *http.Request) {
    // p := Uzytkownicy{Url: "/start"}
    // t, _ := template.ParseFiles("pocz.html")
    // t.Execute(w, p)

if r.Method == "POST" {
Login := r.FormValue("Login")
Haslo := r.FormValue("Haslo")
    db, err := sql.Open("mysql", "finley:password@tcp(127.0.0.1:3306)/baza")
    if err != nil {panic(err.Error())}
    defer db.Close()
// fmt.Println(Login)
   rows, err := db.Query("SELECT COUNT(*)  FROM baza.uzytkownicy WHERE login=?", Login)

    // if err != nil {panic(err.Error())}
               var login int
    for rows.Next() {


    err = rows.Scan(&login)
     fmt.Println(login)}
    // if err != nil {panic(err.Error())}

    fmt.Println(Login)

    if login==0{
    fmt.Println("nie ma loginu")

     insert, err := db.Query("INSERT INTO uzytkownicy (login, haslo) VALUES ( ?,? )",Login, Haslo)
    if err != nil {
        panic(err.Error())
    }
    defer insert.Close()

 p := komunikat{Opis: ""}
    t, _ := template.ParseFiles("logowanie.html")
    t.Execute(w, p)
}else{
 p := komunikat{Opis: "Ten login jest już zajęty"}
    t, _ := template.ParseFiles("rejestracja.html")
    t.Execute(w, p)

}


}else{
  p := komunikat{Opis: ""}
    t, _ := template.ParseFiles("rejestracja.html")
    t.Execute(w, p)
    }

}




func start(w http.ResponseWriter, r *http.Request) {
    p := Uzytkownicy{Url: "/start"}
    t, _ := template.ParseFiles("start.html")
    t.Execute(w, p)


}


func main() {
 db, err := sql.Open("mysql", "finley:password@tcp(127.0.0.1:3306)/baza") 
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()
/*
//wpisywanie do bazy
    insert, err := db.Query("INSERT INTO trening_rzeczywisty VALUES ( 1, 1, 1, 22, 33, 44 )")
    if err != nil {
        panic(err.Error())
    }
    defer insert.Close()
    */
    
//wybieranie z bazy 
/*   results, err := db.Query("SELECT login FROM uzytkownicy")
    if err != nil {
        panic(err.Error())
    }

    for results.Next() {
        var login string
        err = results.Scan(&login)
        if err != nil {
            panic(err.Error()) 
        }
        fmt.Printf(login)
    }*/
/*
//usuwanie wiersza z bazy 
   insertq, err := db.Query("DELETE FROM uzytkownicy WHERE id_uzytkownik=4")
    if err != nil {
        panic(err.Error())
    }
 defer insertq.Close()
*/
	http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
	http.HandleFunc("/wypisz/", wypiszHandler)
	http.HandleFunc("/logowanie", logowanieHandler)
    http.HandleFunc("/planer/", planowanieTreningu)
    http.HandleFunc("/cwiczenie/", opisCwiczenia)
    http.HandleFunc("/wyniki/", wynikiHandler)
    http.HandleFunc("/dodajcwiczenie/", dodaj_cwiczenieHandler)
     http.HandleFunc("/rejestracja/", rejestracja)

    http.HandleFunc("/start/", start)
	http.ListenAndServe(":8099", nil)

}