telegram/repository/repository.v

module repository

import models
import db.pg

// todo дообработать ошибки сейчас что то не возвращаются они

pub struct Repo {
	pub mut:
	db map[string]string
	pg_db pg.DB
	data_set_map map[string]models.Question
}

pub fn (mut r Repo) connect_to_db(cfg pg.Config) ! {
	r.pg_db = pg.connect(cfg)!
	println('Connected to the database successfully.')
}


pub fn (mut r Repo)save_state(chat_id string,state string)  {
	r.db[chat_id]=state
	println(r.db)
}

// pub fn (mut r Repo)get_state(chat_id string)!string{
// 	if chat_id in r.db {
// 		return r.db[chat_id]
// 	}
// 	return error('empty key')
// }

pub fn (mut r Repo)get_next_que_data(state string)!models.Question{
	if state in r.data_set_map {
		return r.data_set_map[state]
	}
	return error('empty')
}

// todo допилить работу со стейтами, надо понять как без telegram id стейт получать и обновлять
// методы QuizRespondentState
// вызывается при /start, создает запись
pub fn (mut r Repo) create_state(state models.RespondentState) !i64 {
	state_id := sql r.pg_db {
		insert state into models.RespondentState
	} or {
		return error('Failed insert state: $err')
	}
	return state_id
}

// вызывать при любом другом, кроме вопроса с типом result
pub fn (mut r Repo) update_state(id i64, new_state i64) ! {
	sql r.pg_db {
		update models.RespondentState set state = new_state where id == id
	} or {
		return error('Failed update state: $err')
	}
}

pub fn (mut r Repo) get_state(state_id i64)!models.RespondentState{
	result := sql r.pg_db {
		select from models.RespondentState where id == state_id
	}or{
		return error('error getting state from db')
	}

	if result.len == 0{
		return error('state not found')
	}

	return result[0]
}

// выставляется при типе вопроса result = true
pub fn (mut r Repo) finish_state(id i64) ! {
	sql r.pg_db {
		update models.RespondentState set finish = true where id == id
	} or {
		return error('Failed finish state: $err')
	}
}

pub fn (mut r Repo) get_state_by_tg_quiz_id(tg_id int,quiz_id i64)!models.RespondentState  {
	result := sql r.pg_db {
		select from models.RespondentState where quiz_id == quiz_id && telegram_id == tg_id && finish == false
	}or{
		return error('error getting state from db')
	}

	if result.len == 0{
		return error('state not found')
	}

	return result[0]
}

pub fn (mut r Repo)get_state_by_tg_quiz_id_finish_true(tg_id int,quiz_id i64)!int  {
	result := sql r.pg_db {
		select from models.RespondentState where quiz_id == quiz_id && telegram_id == tg_id && finish == true
	}or{
		return error('error getting state from db')
	}

	if result.len == 0{
		return 0
	}

	return result.len
}

// методы с question
// получение вопроса по id
pub fn (mut r Repo) get_question_by_id(id i64) !models.QuizQuestion {
	question := sql r.pg_db {
		select from models.QuizQuestion where id == id && deleted == false
	} or {
		return error('Question not found')
	}

	if question.len==0{
		return error('Question not found')
	}

	return question[0]
}

pub fn (mut r Repo) get_questions_by_quiz_id(quiz_id i64) ![]models.QuizQuestion {
	question := sql r.pg_db {
		select from models.QuizQuestion where quiz_id == quiz_id  && deleted == false order by page
	} or {
		return error('question not found for quiz_id')
	}

	if question.len==0{
		return error("not found")
	}

	return question
}

pub fn (mut r Repo) get_all_results(id i64)![]models.QuizQuestion  {
	result := sql r.pg_db {
		select from models.QuizQuestion where quiz_id == id && question_type == models.question_type_result.str() && deleted ==false
	} or {
		return error('question with type result not found for quiz_id')
	}

	return result
}

// методы Quiz

pub fn (mut r Repo) get_quiz(quiz_id i64)!models.Quiz  {
	result := sql r.pg_db{
		select from models.Quiz where id == quiz_id && deleted == false && archived == false
	}or{
		return error('QUIZ not found')
	}

	if result.len == 0{
		return error('QUIZ not found')
	}

	return result[0]
}

// методы TelegramIntegration
// получение интеграции по id
pub fn (mut r Repo) get_integration_by_id(id i64) !models.TelegramIntegration {
	integration := sql r.pg_db {
		select from models.TelegramIntegration where id == id && deleted == false limit 1
	} or {
		return error('Integration not found')
	}

	if integration.len == 0 {
		return error('Integration not found')
	}

	return integration[0]
}

// создает запись о интеграции
pub fn (mut r Repo) create_integration(integration models.TelegramIntegration) !int {
	integration_id := sql r.pg_db {
		insert integration into models.TelegramIntegration
	} or {
		return error('Failed create integration: $err')
	}
	return integration_id
}

// обновляет токен бота
pub fn (mut r Repo) update_bot_token(id i64, new_token string) ! {
	sql r.pg_db {
		update models.TelegramIntegration set bot_token = new_token where id == id && deleted == false
	} or {
		return error('Failed to update bot token: $err')
	}
}

// обновляет поля ниже токена
pub fn (mut r Repo) update_integration_fields(id i64, integration models.TelegramIntegration) ! {
	sql r.pg_db {
		update models.TelegramIntegration set repeatable = integration.repeatable, bot_name = integration.bot_name, deleted = integration.deleted where id == id && deleted == false
	} or {
		return error('Failed update integration fields: $err')
	}
}

pub fn (mut r Repo)soft_delete_integration(quiz_id i64)!{
	sql r.pg_db{
		update models.TelegramIntegration set deleted = true where quiz_id == quiz_id
	}or{
		return error('Failed soft delete integration: $err')
	}
}

pub fn (mut r Repo) update_bot_name(bot_id i64,name string)!{
	sql r.pg_db {
		update models.TelegramIntegration set bot_name = name where id == bot_id
	}or{
		return error('Failed update bot name: $err')
	}
}

// методы telegram_user_quiz_result
pub fn (mut r Repo) create_record_user_result(data models.TelegramUserQuizResult) ! {
	sql r.pg_db {
		insert data into models.TelegramUserQuizResult
	} or {
		return error('Failed create record user result: $err')
	}
}

pub fn (mut r Repo) update_record_user_result(data models.TelegramUserQuizResult)!{
	sql r.pg_db {
		update models.TelegramUserQuizResult set current_field = data.current_field,user_answer = data.user_answer, state = data.state,iter = data.iter  where session == data.session
	}or{
		return error('Failed update bot name: $err')
	}
}

pub fn (r Repo) get_record_user_result(ses string)!models.TelegramUserQuizResult  {
	result := sql r.pg_db{
		select from models.TelegramUserQuizResult where session == ses && state == models.user_result_tg_status_in_progress.str()
	}or{
		return error('record user result not found')
	}

	if result.len == 0{
		return error('record user result not found')
	}

	return result[0]
}

// закрываем соединение с бд
pub fn (mut r Repo)stop_db(){
	r.pg_db.close()
}