// src/server/mod.rs
use crate::table_structure::handlers;
use tonic::{Request, Response, Status};
use tonic_reflection::server::Builder as ReflectionBuilder;
use crate::adresar::handlers::{
    post_adresar, get_adresar, put_adresar, delete_adresar, get_adresar_count, get_adresar_by_position,
};
use crate::uctovnictvo::handlers::{
    post_uctovnictvo, get_uctovnictvo, get_uctovnictvo_count, get_uctovnictvo_by_position,
    put_uctovnictvo,
};
use crate::proto::multieko2::{
    common::{Empty, CountResponse, PositionRequest},
    table_structure::{TableStructureResponse, TableColumn},
    FILE_DESCRIPTOR_SET,
};
use crate::proto::multieko2::adresar::{
    adresar_server::{Adresar, AdresarServer},
    PostAdresarRequest, AdresarResponse, GetAdresarRequest, PutAdresarRequest,
    DeleteAdresarRequest, DeleteAdresarResponse,
};
use crate::proto::multieko2::uctovnictvo::{
    uctovnictvo_server::{Uctovnictvo, UctovnictvoServer},
    PostUctovnictvoRequest, UctovnictvoResponse, GetUctovnictvoRequest, PutUctovnictvoRequest,
};
use crate::proto::multieko2::table_structure::table_structure_service_server::{
    TableStructureService, TableStructureServiceServer,
};
pub struct AdresarService {
    db_pool: sqlx::PgPool,
}

pub struct UctovnictvoService {
    db_pool: sqlx::PgPool,
}

pub struct TableStructureHandler {
    db_pool: sqlx::PgPool
}

#[tonic::async_trait]
impl Adresar for AdresarService {
    async fn post_adresar(
        &self,
        request: Request<PostAdresarRequest>,
    ) -> Result<Response<AdresarResponse>, Status> {
        let response = post_adresar(&self.db_pool, request.into_inner()).await?;
        Ok(Response::new(response))
    }

    async fn get_adresar(
        &self,
        request: Request<GetAdresarRequest>,
    ) -> Result<Response<AdresarResponse>, Status> {
        let response = get_adresar(&self.db_pool, request.into_inner()).await?;
        Ok(Response::new(response))
    }

    async fn put_adresar(
        &self,
        request: Request<PutAdresarRequest>,
    ) -> Result<Response<AdresarResponse>, Status> {
        let response = put_adresar(&self.db_pool, request.into_inner()).await?;
        Ok(Response::new(response))
    }

    async fn delete_adresar(
        &self,
        request: Request<DeleteAdresarRequest>,
    ) -> Result<Response<DeleteAdresarResponse>, Status> {
        let response = delete_adresar(&self.db_pool, request.into_inner()).await?;
        Ok(Response::new(response))
    }

    async fn get_adresar_count(
        &self,
        request: Request<Empty>,
    ) -> Result<Response<CountResponse>, Status> {
        let response = get_adresar_count(&self.db_pool, request.into_inner()).await?;
        Ok(Response::new(response))
    }

    async fn get_adresar_by_position(
        &self,
        request: Request<PositionRequest>,
    ) -> Result<Response<AdresarResponse>, Status> {
        let response = get_adresar_by_position(&self.db_pool, request.into_inner()).await?;
        Ok(Response::new(response))
    }
}

#[tonic::async_trait]
impl Uctovnictvo for UctovnictvoService {
    async fn post_uctovnictvo(
        &self,
        request: Request<PostUctovnictvoRequest>,
    ) -> Result<Response<UctovnictvoResponse>, Status> {
        let response = post_uctovnictvo(&self.db_pool, request.into_inner()).await?;
        Ok(Response::new(response))
    }

    async fn get_uctovnictvo(
        &self,
        request: Request<GetUctovnictvoRequest>,
    ) -> Result<Response<UctovnictvoResponse>, Status> {
        let response = get_uctovnictvo(&self.db_pool, request.into_inner()).await?;
        Ok(Response::new(response))
    }

    async fn get_uctovnictvo_count(
        &self,
        request: Request<Empty>,
    ) -> Result<Response<CountResponse>, Status> {
        let response = get_uctovnictvo_count(&self.db_pool, request.into_inner()).await?;
        Ok(Response::new(response))
    }

    async fn get_uctovnictvo_by_position(
        &self,
        request: Request<PositionRequest>,
    ) -> Result<Response<UctovnictvoResponse>, Status> {
        let response = get_uctovnictvo_by_position(&self.db_pool, request.into_inner()).await?;
        Ok(Response::new(response))
    }

    async fn put_uctovnictvo(
        &self,
        request: Request<PutUctovnictvoRequest>,
    ) -> Result<Response<UctovnictvoResponse>, Status> {
        let response = put_uctovnictvo(&self.db_pool, request.into_inner()).await?;
        Ok(Response::new(response))
    }
}

#[tonic::async_trait]
impl TableStructureService for TableStructureHandler {
    async fn get_adresar_table_structure(
        &self,
        request: Request<crate::proto::multieko2::common::Empty>,
    ) -> Result<Response<TableStructureResponse>, Status> {
        let response = handlers::get_adresar_table_structure(&self.db_pool, request.into_inner())
            .await?;
        Ok(Response::new(response))
    }

    async fn get_uctovnictvo_table_structure(
        &self,
        request: Request<crate::proto::multieko2::common::Empty>,
    ) -> Result<Response<TableStructureResponse>, Status> {
        let response =
            handlers::get_uctovnictvo_table_structure(&self.db_pool, request.into_inner()).await?;
        Ok(Response::new(response))
    }
}

pub async fn run_server(db_pool: sqlx::PgPool) -> Result<(), Box<dyn std::error::Error>> {
    let addr = "[::1]:50051".parse()?;
    let adresar_service = AdresarService { db_pool: db_pool.clone() };
    let uctovnictvo_service = UctovnictvoService { db_pool: db_pool.clone() };
    let table_structure_service = TableStructureHandler { db_pool: db_pool.clone() };

    println!("Server listening on {}", addr);

    let reflection_service = ReflectionBuilder::configure()
        .register_encoded_file_descriptor_set(FILE_DESCRIPTOR_SET)
        .build_v1()
        .unwrap();

    tonic::transport::Server::builder()
        .add_service(AdresarServer::new(adresar_service))
        .add_service(UctovnictvoServer::new(uctovnictvo_service))
        .add_service(TableStructureServiceServer::new(table_structure_service))
        .add_service(reflection_service)
        .serve(addr)
        .await?;

    Ok(())
}