use std::{sync::Arc, pin::Pin};

use actix_web::{get, post, put, delete, web, HttpResponse, HttpRequest, ResponseError};
use log::warn;
use serde::{Serialize, Deserialize};
use serenity::model::prelude::{GuildChannel, ChannelType};
use siren::ServiceError;

use crate::{AppState, bot::commands::audio::{play::play_track, join}};

#[get("/guilds")]
async fn get_guilds(data: web::Data<Arc<AppState>>) -> HttpResponse {
  let guild_results = &data.http.get_guilds(None, None).await;
  let guilds = match guild_results {
    Ok(guilds) => guilds,
    Err(err) => return ResponseError::error_response(&ServiceError {
      status: 422,
      message: err.to_string()
    })
  };
  HttpResponse::Ok().json(guilds)
}

#[get("/{id}/text")]
async fn get_text_channels(id: web::Path<String>, data: web::Data<Arc<AppState>>) -> HttpResponse {
  let channel_results = &data.http.get_channels(id.parse::<u64>().unwrap()).await;
  let channels = match channel_results {
    Ok(channels) => channels.iter().filter(|c| c.kind == ChannelType::Text).collect::<Vec<&GuildChannel>>(),
    Err(err) => return ResponseError::error_response(&ServiceError {
      status: 422,
      message: err.to_string()
    })
  };
  HttpResponse::Ok().json(channels)
}

#[get("/{id}/voice")]
async fn get_voice_channels(id: web::Path<String>, data: web::Data<Arc<AppState>>) -> HttpResponse {
  let channel_results = &data.http.get_channels(id.parse::<u64>().unwrap()).await;
  let channels = match channel_results {
    Ok(channels) => channels.iter().filter(|c| c.kind == ChannelType::Voice).collect::<Vec<&GuildChannel>>(),
    Err(err) => return ResponseError::error_response(&ServiceError {
      status: 422,
      message: err.to_string()
    })
  };
  HttpResponse::Ok().json(channels)
}

#[derive(Serialize, Deserialize)]
struct ChannelMessage {
  message: String
}

#[post("/{guild_id}/text/{channel_id}/message")]
async fn send_message(path: web::Path<(String, String)>, text: web::Json<ChannelMessage>, data: web::Data<Arc<AppState>>) -> HttpResponse {
  let (guild_id, channel_id) = path.into_inner();
  let guild_id = match guild_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      warn!("Could not parse guild id: {:?}", err);
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };
  let channel_id = match channel_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      warn!("Could not parse channel id: {:?}", err);
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };
  let channel_results = &data.http.get_channels(guild_id).await;
  let channels = match channel_results {
    Ok(channels) => channels,
    Err(err) => {
      warn!("Could not get channels: {:?}", err);
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };
  
  let channel = match channels.iter().find(|c| c.id.0 == channel_id) {
    Some(channel) => channel,
    None => {
      warn!("Could not find channel with id {}", channel_id);
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: format!("Could not find channel with id {}", channel_id)
      })
    }
  };

  if let Err(err) = channel.say(&Pin::new(&data.http).get_ref(), &text.message).await {
    warn!("Could not send message: {:?}", err);
    return ResponseError::error_response(&ServiceError {
      status: 422,
      message: err.to_string()
    })
  };

  HttpResponse::Ok().finish()
}

#[derive(Serialize, Deserialize)]
struct PlayRequest {
  track_url: String
}

#[post("/{guild_id}/voice/{channel_id}/play")]
async fn play(path: web::Path<(String, String)>, play_request: web::Json<PlayRequest>, data: web::Data<Arc<AppState>>) -> HttpResponse {
  let (guild_id, channel_id) = path.into_inner();
  let guild_id = match guild_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      warn!("Could not parse guild id: {:?}", err);
      return ResponseError::error_response(&ServiceError { status: 422, message: err.to_string() })
    }
  };
  let channel_id = match channel_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      warn!("Could not parse channel id: {:?}", err);
      return ResponseError::error_response(&ServiceError { status: 422, message: err.to_string() })
    }
  };
  let http = Pin::new(&data.http).get_ref();
  let guild = match http.get_guild(guild_id).await {
    Ok(guild) => guild,
    Err(err) => {
      warn!("Could not get guild: {:?}", err);
      return ResponseError::error_response(&ServiceError { status: 422, message: err.to_string() })
    }
  };
  let channel = match http.get_channel(channel_id).await {
    Ok(channel) => channel,
    Err(err) => {
      warn!("Could not get channel: {:?}", err);
      return ResponseError::error_response(&ServiceError { status: 422, message: err.to_string() })
    }
  };

  let manager = Arc::clone(&data.songbird);

  match join(Arc::clone(&manager), &guild.id, &channel.id()).await {
    Ok(_) => {
      match play_track(Arc::clone(&data.songbird), guild.id, play_request.track_url.to_string()).await {
        Ok(_) => HttpResponse::Ok().finish(),
        Err(err) => {
          warn!("Could not play track: {:?}", err);
          return ResponseError::error_response(&err)
        }
      }
    },
    Err(err) => {
      warn!("Could not join channel: {:?}", err);
      return ResponseError::error_response(&ServiceError { status: 500, message: err.to_string() })
    }
  }
}

#[post("/{guild_id}/voice/stop")]
async fn stop(path: web::Path<String>, data: web::Data<Arc<AppState>>) -> HttpResponse {
  let guild_id = path.into_inner();
  let guild_id = match guild_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      warn!("Could not parse guild id: {:?}", err);
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };

  if let Some(handler_lock) = data.songbird.get(guild_id) {
    let handler = handler_lock.lock().await;
    handler.queue().stop();
  }

  HttpResponse::Ok().finish()
}

#[post("/{guild_id}/voice/resume")]
async fn resume(path: web::Path<String>, data: web::Data<Arc<AppState>>) -> HttpResponse {
  let guild_id = path.into_inner();
  let guild_id = match guild_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      warn!("Could not parse guild id: {:?}", err);
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };

  if let Some(handler_lock) = data.songbird.get(guild_id) {
    let handler = handler_lock.lock().await;
    if let Err(err) = handler.queue().resume() {
      warn!("Could not resume track: {:?}", err);
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  }

  HttpResponse::Ok().finish()
}

#[post("/{guild_id}/voice/pause")]
async fn pause(path: web::Path<String>, data: web::Data<Arc<AppState>>) -> HttpResponse {
  let guild_id = path.into_inner();
  let guild_id = match guild_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      warn!("Could not parse guild id: {:?}", err);
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };

  if let Some(handler_lock) = data.songbird.get(guild_id) {
    let handler = handler_lock.lock().await;
    if let Err(err) = handler.queue().pause() {
      warn!("Could not pause track: {:?}", err);
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  }

  HttpResponse::Ok().finish()
}

pub fn init_routes(config: &mut web::ServiceConfig) {
  config
    .service(get_guilds)
    .service(web::scope("guilds")
      .service(get_text_channels)
      .service(get_voice_channels)
      .service(send_message)
      .service(play)
      .service(stop)
      .service(resume)
      .service(pause)
  );
}