#![allow(unused)]
use actix::{Actor, StreamHandler};
use actix_files::{Files, NamedFile};
use actix_form_data::{Error, Field, Value};
use actix_identity::Identity;
use actix_identity::{CookieIdentityPolicy, IdentityService};
use actix_multipart::Multipart;
use actix_web::{
    cookie::Cookie, get, http, middleware, post, web, web::Data, web::Form, web::Path as Pathweb,
    App, HttpRequest, HttpResponse, HttpServer, Responder,
};
use actix_web_actors::ws;

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::{fs::*, default};
use std::path::*;
use std::process::Command;
use tera::{Context, Tera};

#[macro_use]
extern crate diesel;
use diesel::prelude::*;

pub mod schema;
use schema::users;
pub mod models;
use models::{User, Project, Entity};

use walkdir::{DirEntry, WalkDir};

mod user_controller;

mod response;
mod util;
use util::*;
// use response::MyError;

use futures_util::TryStreamExt as _;
use std::io::Write;
use tempfile::tempfile;
use uuid::Uuid;

use std::fs::File;
use std::io::{self, prelude::*, BufReader};

struct Ws {}

impl Actor for Ws {
    type Context = ws::WebsocketContext<Self>;

    fn started(&mut self, ctx: &mut Self::Context) {}
}

/// Handler for ws::Message message
impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for Ws {
    fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
        match msg {
            Ok(ws::Message::Ping(msg)) => {
                println!("msg: {:?}", msg);
                ctx.pong(&msg)
            }
            Ok(ws::Message::Text(text)) => {
                // println!("text: {:?}", text);
                // ctx.text(text);
                let str = &text.to_string();
                if str == &"Coucou le serveur !".to_string() {
                    // println!("text: {:?}", str);
                    // println!("user: {:?}", User::find(1).unwrap());
                    return ctx.text(text);
                }
                ctx.text(text)
            }
            Ok(ws::Message::Binary(bin)) => {
                println!("bin: {:?}", bin);
                ctx.binary(bin)
            }
            _ => (),
        }
    }
}

#[get("/ws")]
async fn websocket(req: HttpRequest, stream: web::Payload) -> impl Responder {
    let resp = ws::start(Ws {}, &req, stream);
    // println!("{:#?}", &ws);
    resp
}

#[get("/")]
async fn index(tmpl: Data<Tera>, id: Identity) -> impl Responder {
    let mut context = Context::new();
    let result_user = get_user_session(&id);
    if !result_user.is_err() {
        let user_session = result_user.unwrap();
        context.insert("user", &user_session);
    }
    let projects = Project::find_by_public(true).unwrap();
    let mut projects_json = Vec::<serde_json::Value>::new();
    for project in projects  {
        projects_json.push(project.to_json());
    }
    context.insert("projects_json",&projects_json);
    response::template(tmpl, "index.html.twig", &context)
}

#[get("/home")]
async fn home(tmpl: Data<Tera>, id: Identity) -> impl Responder {
    let mut context = Context::new();
    response::template(tmpl, "home.html.twig", &context)
}

async fn not_found(req: HttpRequest, tmpl: Data<Tera>, id: Identity) -> impl Responder {
    let context = Context::new();
    response::just_404(tmpl)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        let tera = Tera::new(concat!(env!("CARGO_MANIFEST_DIR"), "/templates/**/*")).unwrap();
        let mut folder_static = "static/";
        App::new()
            .app_data(Data::new(tera))
            .wrap(IdentityService::new(
                CookieIdentityPolicy::new(&[0; 32])
                    .name("dr_who_website")
                    .secure(true)
                    .max_age_secs(60 * 60 * 24 * 7), // 1week
            ))
            .wrap(middleware::Logger::default())
            .service(index)
            .service(user_controller::login)
            .service(user_controller::post_login)
            .service(user_controller::post_auth)
            .service(user_controller::post_auth_user)
            .service(user_controller::register)
            .service(user_controller::post_register)
            .service(user_controller::logout)
            .service(user_controller::register_google)
            .service(user_controller::post_register_google)
            .service(user_controller::user_validate)
            .service(user_controller::forgotpassword)
            .service(user_controller::post_forgotpassword)
            .service(user_controller::change_password)
            .service(user_controller::post_change_password)
            .service(user_controller::profile)
            .service(user_controller::profile_post)
            .service(user_controller::delete)
            .service(user_controller::user_deleted)
            .service(websocket)
            .service(home)
            .service(Files::new("/static", folder_static))
            .default_service(web::route().to(not_found))
    })
    .workers(8)
    .bind(("0.0.0.0", 80))?
    .run()
    .await
}