package main

import (
	"context"
	"encoding/json"
	"fmt"
	"gibb165lb2/util"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"net/http"
	"time"

	"github.com/gorilla/mux"
)

var client *mongo.Client

// func to insert 10 random persons with real names  into the database and create 30 random debts for them

func getDebtsForPerson(client *mongo.Client, personID string) ([]util.Debt, error) {
	var results []util.Debt

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	// Umwandlung der personID von string in primitive.ObjectID
	objID, err := primitive.ObjectIDFromHex(personID)
	if err != nil {
		return nil, err
	}

	// Verbindung zur "debts" Sammlung
	debtsCollection := client.Database("debtlist").Collection("debts")

	// Abfrage erstellen, die alle Schulden findet, deren fk_pid mit der personID übereinstimmt
	filter := bson.M{"fk_pid": objID}
	cursor, err := debtsCollection.Find(ctx, filter)
	if err != nil {
		return nil, err
	}
	defer cursor.Close(ctx)

	// Durchlaufen des Cursors und Hinzufügen der Ergebnisse zur results-Slice
	for cursor.Next(ctx) {
		var debt util.Debt
		if err := cursor.Decode(&debt); err != nil {
			return nil, err
		}
		results = append(results, debt)
	}

	if err := cursor.Err(); err != nil {
		return nil, err
	}

	return results, nil
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	var err error
	client, err = mongo.Connect(ctx, options.Client().ApplyURI("mongodb://root:root12345@localhost:27017"))
	if err != nil {
		panic(err)
	}
	//util.InsertRandomData(client)
	// Router initialisieren
	r := mux.NewRouter()
	r.HandleFunc("/persons", createPerson).Methods("POST")
	r.HandleFunc("/persons/{id}", getPerson).Methods("GET")
	r.HandleFunc("/persons", getAllPersons).Methods("GET")
	r.HandleFunc("/personsWithDebts", getPersonsWithDebts).Methods("GET")
	r.HandleFunc("/persons/{id}", updatePerson).Methods("PUT")
	r.HandleFunc("/persons/{id}", deletePerson).Methods("DELETE")
	r.HandleFunc("/persons/{id}/debts", getDebts).Methods("GET")
	r.HandleFunc("/persons/{id}/debts", createDebt).Methods("POST")
	r.HandleFunc("/debts/{id}", deleteDebt).Methods("DELETE")
	r.HandleFunc("/debts", getAllDebts).Methods("GET")
	r.HandleFunc("/debts/{id}", getDebt).Methods("GET")
	r.HandleFunc("/debts/{id}", updateDebt).Methods("PUT")

	err = http.ListenAndServe(":3333", r)
	if err != nil {
		log.Fatal(err)
	}
}

func createPerson(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	var person util.Person
	json.NewDecoder(r.Body).Decode(&person)
	collection := client.Database("debtlist").Collection("persons")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	result, err := collection.InsertOne(ctx, person)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return

	}
	json.NewEncoder(w).Encode(result)
}
func updatePerson(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	var person util.Person
	vars := mux.Vars(r)
	personID := vars["id"]
	person.ID, _ = primitive.ObjectIDFromHex(personID)
	json.NewDecoder(r.Body).Decode(&person)
	fmt.Println(person)

	collection := client.Database("debtlist").Collection("persons")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	filter := bson.M{"_id": person.ID}
	update := bson.M{
		"$set": bson.M{
			"name":  person.Name,
			"age":   person.Age,
			"email": person.Email,
		},
	}
	result, err := collection.UpdateOne(ctx, filter, update)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return

	}
	json.NewEncoder(w).Encode(result)
}
func deletePerson(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	vars := mux.Vars(r)
	personID := vars["id"]
	collection := client.Database("debtlist").Collection("persons")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	newPersonID, err := primitive.ObjectIDFromHex(personID)
	filter := bson.M{"_id": newPersonID}
	result, err := collection.DeleteOne(ctx, filter)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return
	}
	json.NewEncoder(w).Encode(result)
}
func getPerson(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	personID := vars["id"]
	w.Header().Set("Content-Type", "application/json")
	var person util.Person
	collection := client.Database("debtlist").Collection("persons")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	pid, err := primitive.ObjectIDFromHex(personID)
	filter := bson.M{"_id": pid}
	err = collection.FindOne(ctx, filter).Decode(&person)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return
	}
	json.NewEncoder(w).Encode(person)
}
func getAllPersons(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	var persons []util.Person
	collection := client.Database("debtlist").Collection("persons")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	cursor, err := collection.Find(ctx, bson.M{})
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return
	}
	defer cursor.Close(ctx)
	for cursor.Next(ctx) {
		var person util.Person
		cursor.Decode(&person)
		persons = append(persons, person)
	}
	if err := cursor.Err(); err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return
	}
	json.NewEncoder(w).Encode(persons)
}

func getDebts(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	personID := vars["id"]
	w.Header().Set("Content-Type", "application/json")
	debts, err := getDebtsForPerson(client, personID)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return
	}
	json.NewEncoder(w).Encode(debts)
}

func createDebt(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	w.Header().Set("Content-Type", "application/json")
	var debt util.Debt
	personID := vars["id"]
	json.NewDecoder(r.Body).Decode(&debt)
	debt.PersonID, _ = primitive.ObjectIDFromHex(personID)
	collection := client.Database("debtlist").Collection("debts")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	result, err := collection.InsertOne(ctx, debt)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return
	}
	json.NewEncoder(w).Encode(result)
}

func deleteDebt(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	w.Header().Set("Content-Type", "application/json")
	var debt util.Debt
	debtId := vars["id"]
	json.NewDecoder(r.Body).Decode(&debt)
	debt.ID, _ = primitive.ObjectIDFromHex(debtId)
	collection := client.Database("debtlist").Collection("debts")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	filter := bson.M{"_id": debt.ID}
	result, err := collection.DeleteOne(ctx, filter)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return
	}
	json.NewEncoder(w).Encode(result)
}

func getAllDebts(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	var debts []util.Debt
	collection := client.Database("debtlist").Collection("debts")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	cursor, err := collection.Find(ctx, bson.M{})
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return
	}
	defer cursor.Close(ctx)
	for cursor.Next(ctx) {
		var debt util.Debt
		cursor.Decode(&debt)
		debts = append(debts, debt)
	}
	if err := cursor.Err(); err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return
	}
	json.NewEncoder(w).Encode(debts)
}

// eine route welche alle personen zurückgibt welche ein array aus debts haben.
func getPersonsWithDebts(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	var personsWithDebts []util.PersonWithDebts
	var persons []util.Person
	collection := client.Database("debtlist").Collection("persons")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	cursor, err := collection.Find(ctx, bson.M{})
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return
	}
	defer cursor.Close(ctx)
	for cursor.Next(ctx) {
		var person util.Person
		cursor.Decode(&person)
		persons = append(persons, person)
	}
	if err := cursor.Err(); err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return
	}
	for _, person := range persons {
		debts, err := getDebtsForPerson(client, person.ID.Hex())
		if err != nil {
			w.WriteHeader(http.StatusInternalServerError)
			w.Write([]byte(`{"message": "` + err.Error() + `"}`))
			return
		}
		personsWithDebts = append(personsWithDebts, util.PersonWithDebts{Person: person, Debts: debts})
	}
	json.NewEncoder(w).Encode(personsWithDebts)
}

// neue route welche eine einzelne debt zurückgibt
func getDebt(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	debtID := vars["id"]
	w.Header().Set("Content-Type", "application/json")
	var debt util.Debt
	collection := client.Database("debtlist").Collection("debts")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	did, err := primitive.ObjectIDFromHex(debtID)
	filter := bson.M{"_id": did}
	err = collection.FindOne(ctx, filter).Decode(&debt)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return
	}
	json.NewEncoder(w).Encode(debt)
}

// neue route welche eine einzelne debt aktualisiert
func updateDebt(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	var debt util.Debt
	vars := mux.Vars(r)
	debtID := vars["id"]
	debt.ID, _ = primitive.ObjectIDFromHex(debtID)
	json.NewDecoder(r.Body).Decode(&debt)
	collection := client.Database("debtlist").Collection("debts")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	filter := bson.M{"_id": debt.ID}
	update := bson.M{
		"$set": bson.M{
			"fk_pid":      debt.PersonID,
			"amount":      debt.Amount,
			"description": debt.Description,
			"datetime":    debt.Datetime,
		},
	}
	result, err := collection.UpdateOne(ctx, filter, update)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte(`{"message": "` + err.Error() + `"}`))
		return
	}
	json.NewEncoder(w).Encode(result)
}