pub mod motor_control_service {
    tonic::include_proto!("motor_control");
}

use std::sync::{Arc, Mutex};

use car_rs::{Servo, Vehicle};
use motor_control_service::car_control_server::CarControl;
use tonic::{Request, Response, Status, Streaming};

use futures_util::StreamExt;

use self::motor_control_service::{
    RecordingReqeust, RecordingResponse, SaveRequest, SaveResponse, SteeringRequest,
    SteeringResponse, ThrottleRequest, ThrottleResponse, Vehicle2DRequest, Vehicle2DResponse,
};

#[derive(Debug)]
pub struct MotorControlService {}

#[tonic::async_trait]
impl CarControl for MotorControlService {
    async fn set_throttle(
        &self,
        _request: Request<ThrottleRequest>,
    ) -> Result<Response<ThrottleResponse>, Status> {
        unimplemented!()
    }

    async fn set_steering(
        &self,
        _request: Request<SteeringRequest>,
    ) -> Result<Response<SteeringResponse>, Status> {
        unimplemented!()
    }

    async fn stream_vehicle_2d(
        &self,
        request: Request<Streaming<Vehicle2DRequest>>,
    ) -> Result<Response<Vehicle2DResponse>, Status> {
        let mut stream = request.into_inner();

        let mut timed_out = false;
        while let Some(req) = stream.next().await {
            if !timed_out {}
            timed_out = true;
        }

        unimplemented!()
    }

    async fn record(
        &self,
        _request: Request<RecordingReqeust>,
    ) -> Result<Response<RecordingResponse>, Status> {
        unimplemented!()
    }

    async fn save_recorded_data(
        &self,
        _request: Request<SaveRequest>,
    ) -> Result<Response<SaveResponse>, Status> {
        unimplemented!()
    }
}