package repository

import (
	"Zadanie2Project/main/mappers"
	"Zadanie2Project/main/models"
	"context"
	"fmt"
	"log"
)

func (repo *PGrepo) GetPrograms(offset int, limit int) ([]models.ProgramDto, error) {
	rows, err := repo.pool.Query(context.Background(), "select * from Program LIMIT $1 OFFSET $2", limit, offset)
	if err != nil {
		log.Fatal(err)
		return nil, err
	}
	defer rows.Close()
	var programsDto []models.ProgramDto
	for rows.Next() {
		program := models.Program{}
		err := rows.Scan(&program.ID, &program.Publisher, &program.Name, &program.CategoryId, &program.LicenseTypeId,
			&program.Description, &program.URL)
		category, err := repo.GetCategoryWithId(program.CategoryId)
		license, err := repo.GetLicenseWithId(program.LicenseTypeId)
		programDto := mappers.ConvertProgramToDto(program)
		programDto.Category = category
		programDto.LicenseType = license

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

		programsDto = append(programsDto, programDto)
	}
	return programsDto, nil
}
func (repo *PGrepo) GetEmployeesWithFilterByPosition(offset int, limit int, position string) ([]models.Program, error) {
	rows, err := repo.pool.Query(context.Background(), "select * from Program where position = $3 LIMIT $1 OFFSET $2", limit, offset, position)
	if err != nil {
		log.Fatal(err)
		return nil, err
	}
	defer rows.Close()
	var programs []models.Program
	for rows.Next() {
		program := models.Program{}
		err := rows.Scan(&program.ID, &program.Publisher, &program.Name, &program.CategoryId, &program.LicenseTypeId,
			&program.Description, &program.URL)
		if err != nil {
			fmt.Println(err)
			continue
		}
		programs = append(programs, program)
	}
	return programs, nil
}
func (repo *PGrepo) GetProgramVersions(offset int, limit int) ([]models.ProgramVersionsDto, error) {
	rows, err := repo.pool.Query(context.Background(), "select * from ProgramVersions LIMIT $1 OFFSET $2", limit, offset)
	if err != nil {
		log.Fatal(err)
		return nil, err
	}
	defer rows.Close()
	var programVersions []models.ProgramVersionsDto
	for rows.Next() {
		version := models.ProgramVersions{}
		err := rows.Scan(&version.ProgramID, &version.Version, &version.SystemRequirements, &version.LicenseTypeId, &version.URL,
			&version.Date)
		versionDto := mappers.ConvertProgramVersionToDto(version)
		license, err := repo.GetLicenseWithId(version.LicenseTypeId)
		versionDto.LicenseType = license
		if err != nil {
			fmt.Println(err)
			continue
		}
		programVersions = append(programVersions, versionDto)
	}
	return programVersions, nil
}
func (repo *PGrepo) GetLicenseWithId(id int) (models.License, error) {
	rows, err := repo.pool.Query(context.Background(), "select * from License where id = $1", id)
	if err != nil {
		panic(err)
	}
	defer rows.Close()
	var license models.License
	err = rows.Scan(&license.ID, &license.Name)
	if err != nil {
		fmt.Println(err)
	}
	return license, nil
}
func (repo *PGrepo) GetCategoryWithId(id int) (models.Category, error) {
	rows, err := repo.pool.Query(context.Background(), "select * from Category where id = $1", id)
	if err != nil {
		panic(err)
	}
	defer rows.Close()
	var category models.Category
	err = rows.Scan(&category.ID, &category.Name)
	if err != nil {
		fmt.Println(err)
	}
	return category, nil
}