mod api;

api::create(addr, matches.is_present("https")).await;

table! {
    ipv4_history (id) {
        id -> Int4,
        ipv4_address -> Varchar,
        effective_flg -> Bool,
        created_at -> Timestamptz,
        updated_at -> Timestamptz,
        last_checked_at -> Timestamptz,
    }
}

use chrono::{DateTime, Utc};

pub mod schema;
use schema::ipv4_history;

#[allow(dead_code)]
#[derive(Clone, Queryable)]
pub struct Ipv4Record {
    pub id: i32,
    pub ipv4_address: String,
    effective_flg: bool,
    created_at: DateTime<Utc>,
    updated_at: DateTime<Utc>,
    pub last_checked_at: DateTime<Utc>,
}

#[derive(Insertable)]
#[table_name = "ipv4_history"]
pub struct NewIpV4Record {
    pub ipv4_address: String,
    pub effective_flg: bool,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub last_checked_at: DateTime<Utc>,
}

use chrono::Utc;

use diesel::prelude::*;
use diesel::{insert_into, update};

pub mod model;
use model::schema::ipv4_history::dsl::*;
use model::{Ipv4Record, NewIpV4Record};

use dotenv::dotenv;
use std::env;

pub fn establish_connection() -> PgConnection {
    if cfg!(test) | cfg!(debug_assertions) {
        dotenv().ok();
    }

    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    PgConnection::establish(&database_url).expect(&format!("Error connecting to {}", database_url))
}

pub fn get_effective_records(conn: &PgConnection) -> Vec<Ipv4Record> {
    let ipv4_effective = ipv4_history
        .filter(effective_flg.eq(true))
        .load::<Ipv4Record>(conn)
        .expect("Error loading ipv4_history");
    return ipv4_effective;
}

pub fn insert_record(conn: &PgConnection, address: &str) -> Ipv4Record {
    let now = Utc::now();
    let new_ipv4_record = NewIpV4Record {
        ipv4_address: address.to_string(),
        effective_flg: true,
        created_at: now,
        updated_at: now,
        last_checked_at: now,
    };
    insert_into(ipv4_history)
        .values(new_ipv4_record)
        .get_result(conn)
        .expect("Error saving record")
}

pub fn disable_record(conn: &PgConnection, target_id: &i32) -> Ipv4Record {
    update(ipv4_history.find(target_id))
        .set((effective_flg.eq(false), updated_at.eq(Utc::now())))
        .get_result::<Ipv4Record>(conn)
        .expect(&format!("Error Update Record {}", target_id))
}

pub fn update_last_checked_at(conn: &PgConnection, target_id: &i32) -> Ipv4Record {
    let now = Utc::now();
    update(ipv4_history.find(target_id))
        .set((last_checked_at.eq(now), updated_at.eq(now)))
        .get_result::<Ipv4Record>(conn)
        .expect(&format!("Error Update Record {}", target_id))
}

use crate::db;
use db::*;

pub fn get_effective_ipv4_record() -> Result<db::model::Ipv4Record, String> {
    let conn = establish_connection();
    let effective_records = get_effective_records(&conn);

    if effective_records.len() == 0 {
        return Err("IPv4 record not found".into());
    }

    if effective_records.len() > 1 {
        return Err("Too many IPv4 records have been found".into());
    }

    return Ok(effective_records[0].clone());
}

pub fn post_ip4_address(ipv4_address: &str) -> Result<(), String> {
    let conn = establish_connection();
    let effective_records = get_effective_records(&conn);

    if effective_records.len() == 0 {
        insert_record(&conn, ipv4_address);
        return Ok(());
    }

    if effective_records.len() > 1 {
        return Err("Too many IPv4 records have been found".into());
    }

    if ipv4_address == effective_records[0].ipv4_address {
        update_last_checked_at(&conn, &effective_records[0].id);
        return Ok(());
    }

    disable_record(&conn, &effective_records[0].id);
    insert_record(&conn, ipv4_address);
    Ok(())
}

use openapi_client::server::MakeService;
use openapi_client::IpGetResponse::GetGlobalIPv;
use openapi_client::IpPostResponse::*;
use openapi_client::{Api, IpGetResponse, IpPostResponse};
use std::error::Error;
use swagger::ApiError;

use crate::db;
use crate::db::model::schema::ipv4_history::ipv4_address;
use crate::usecase;
use usecase::*;

use models::IpGet200Response;

#[async_trait]
impl<C> Api<C> for Server<C>
where
    C: Has<XSpanIdString> + Send + Sync,
{
    async fn ip_get(&self, context: &C) -> Result<IpGetResponse, ApiError> {
        let context = context.clone();
        info!("get_ip() - X-Span-ID: {:?}", context.get().0.clone());
        match get_effective_ipv4_record() {
            Ok(ipv4_record) => Ok(GetGlobalIPv(IpGet200Response {
                ipv4_address: Some(ipv4_record.ipv4_address.to_string()),
                checked_at: Some(ipv4_record.last_checked_at),
            })),
            Err(e) => Err(ApiError(e.into())),
        }
    }

    async fn ip_post(
        &self,
        ip_get_request: Option<models::IpGetRequest>,
        context: &C,
    ) -> Result<IpPostResponse, ApiError> {
        let context = context.clone();
        info!(
            "ip_post({:?}) - X-Span-ID: {:?}",
            ip_get_request,
            context.get().0.clone()
        );

        if let Some(request) = ip_get_request && let Some(address)=request.ipv4_address && is_ipv4(&address){
            match post_ip4_address(&address) {
                Ok(()) => Ok(TheNewIPv {}),
                Err(e) => Err(ApiError(e.into())),
            }
        } else {
                Ok(BadRequest)
        }
    }
}

use regex::Regex;

 fn is_ipv4(text: &str) -> bool {
    let re = Regex::new(
        r"^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])$",
    ).unwrap();
    re.is_match(text)
}