package models

import (
	"errors"
	"log"
)

type Group struct {
	GroupId   int    `db:"GroupId" json:"groupId"`
	GroupName string `db:"GroupName" json:"groupName"`
	LdapGroup bool   `db:"LdapGroup" json:"ldapGroup"`
	LdapDn    string `db:"LdapDn" json:"ldapDn"`
	Admin     bool   `db:"Admin" json:"admin"`
}

// GroupGetByName queries the database for the specified group name
func GroupGetByName(groupname string) (Group, error) {
	var g Group

	// Query database for matching group object
	err := db.QueryRowx("SELECT * FROM groups WHERE GroupName=?", groupname).StructScan(&g)
	if err != nil {
		return g, errors.New("group not found")
	}

	return g, nil
}

// GroupList returns a list of all groups in database
func GroupList() ([]Group, error) {
	var results []Group

	// Query database for groups
	rows, err := db.Queryx("SELECT * FROM groups")

	if err != nil {
		log.Printf("GroupList error executing sql record : '%s'\n", err)
		return results, err
	} else {
		// parse all the results into a slice
		for rows.Next() {
			var g Group
			err = rows.StructScan(&g)
			if err != nil {
				log.Printf("GroupList error parsing sql record : '%s'\n", err)
				return results, err
			}
			results = append(results, g)

		}
		log.Printf("GroupList retrieved '%d' results\n", len(results))
	}

	return results, nil
}

// GroupAdd adds a new group definition to the database
func (g *Group) GroupAdd() (*Group, error) {
	var err error

	// Validate group not already in use
	_, err = GroupGetByName(g.GroupName)

	if err != nil && err.Error() == "group not found" {
		log.Printf("GroupAdd confirmed no existing group, continuing with creation of group '%s'\n", g.GroupName)

		result, err := db.NamedExec(("INSERT INTO groups (GroupName, LdapGroup, LdapDn, Admin) VALUES (:GroupName, :LdapGroup, :LdapDn, :Admin);"), g)

		if err != nil {
			log.Printf("GroupAdd error executing sql record : '%s'\n", err)
			return &Group{}, err
		} else {
			affected, _ := result.RowsAffected()
			id, _ := result.LastInsertId()
			g.GroupId = int(id)
			log.Printf("GroupAdd insert returned result id '%d' affecting %d row(s).\n", id, affected)
		}
	} else {
		errString := "group with name already exists"
		log.Printf("GroupAdd %s\n", errString)
		return &Group{}, errors.New(errString)
	}

	return g, nil
}

// GroupDelete removes a group definition to the database
func (g *Group) GroupDelete() error {
	var err error

	// Validate group exists
	group, err := GroupGetByName(g.GroupName)
	if err != nil && err.Error() == "group not found" {
		log.Printf("GroupDelete unable to validate group exists : '%s'\n", err)
		return err
	}

	// Make sure we have a group ID
	if g.GroupId == 0 {
		g.GroupId = group.GroupId
	}

	// Delete the group
	log.Printf("GroupDelete confirmed group exists, continuing with deletion of group '%s'\n", g.GroupName)
	result, err := db.NamedExec((`DELETE FROM groups WHERE GroupId = :GroupId`), g)

	if err != nil {
		log.Printf("GroupDelete error executing sql delete : '%s'\n", err)
		return err
	} else {
		affected, _ := result.RowsAffected()
		id, _ := result.LastInsertId()
		log.Printf("GroupDelete returned result id '%d' affecting %d row(s).\n", id, affected)
	}

	return nil
}