use chrono::{Local, NaiveDateTime, NaiveTime};
use sqlx::{query, PgPool};

use super::{assignment_changeset::AssignmentChangeset, Function, Result};

pub struct Assignment {
    pub event_id: i32,
    pub availabillity_id: i32,
    pub function: Function,
    pub start_time: NaiveTime,
    pub end_time: NaiveTime,
}

impl Assignment {
    pub async fn create(
        pool: &PgPool,
        event_id: i32,
        availabillity_id: i32,
        changeset: AssignmentChangeset,
    ) -> Result<()> {
        // TODO: refactor
        let date1 = Local::now();
        let date2 = Local::now();

        query!(
            r##"
                INSERT INTO assignment (eventId, availabillityId, function, startTimestamp, endTimestamp)
                VALUES ($1, $2, $3, $4, $5);
            "##,
            event_id,
            availabillity_id,
            changeset.function as Function,
            date1,
            date2
        )
        .execute(pool)
        .await?;

        Ok(())
    }

    pub async fn read_all_by_availabillity(
        pool: &PgPool,
        availabillity_id: i32,
    ) -> Result<Vec<Assignment>> {
        let records = query!(
            r##"
                SELECT
                    assignment.eventId,
                    assignment.availabillityId,
                    assignment.function AS "function: Function",
                    assignment.startTimestamp,
                    assignment.endTimestamp
                FROM assignment
                WHERE assignment.AvailabillityId = $1;
            "##,
            availabillity_id
        )
        .fetch_all(pool)
        .await?;

        let assignemnets = records
            .iter()
            .map(|r| Assignment {
                event_id: r.eventid,
                availabillity_id: r.availabillityid,
                function: r.function,
                // TODO: refactor
                start_time: r.starttimestamp.time(),
                end_time: r.endtimestamp.time(),
            })
            .collect();

        Ok(assignemnets)
    }

    pub async fn read_all_by_event(pool: &PgPool, event_id: i32) -> Result<Vec<Assignment>> {
        let records = query!(
            r##"
                SELECT
                    assignment.eventId,
                    assignment.availabillityId,
                    assignment.function AS "function: Function",
                    assignment.startTimestamp,
                    assignment.endTimestamp
                FROM assignment
                WHERE assignment.eventId = $1;
            "##,
            event_id,
        )
        .fetch_all(pool)
        .await?;

        let assignemnets = records
            .iter()
            .map(|r| Assignment {
                event_id: r.eventid,
                availabillity_id: r.availabillityid,
                function: r.function,
                // TODO: refactor
                start_time: r.starttimestamp.time(),
                end_time: r.endtimestamp.time(),
            })
            .collect();

        Ok(assignemnets)
    }

    pub async fn read(
        pool: &PgPool,
        event_id: i32,
        availabillity_id: i32,
    ) -> Result<Option<Assignment>> {
        let record = query!(
            r##"
                SELECT
                    assignment.eventId,
                    assignment.availabillityId,
                    assignment.function AS "function: Function",
                    assignment.startTimestamp,
                    assignment.endTimestamp
                FROM assignment
                WHERE
                    assignment.eventId = $1 AND
                    assignment.availabillityId = $2;
            "##,
            event_id,
            availabillity_id
        )
        .fetch_optional(pool)
        .await?;

        let assignemnet = record.map(|r| Assignment {
            event_id: r.eventid,
            availabillity_id: r.availabillityid,
            function: r.function,
            // TODO: refactor
            start_time: r.starttimestamp.time(),
            end_time: r.endtimestamp.time(),
        });

        Ok(assignemnet)
    }

    pub async fn update(
        pool: &PgPool,
        event_id: i32,
        availabillity_id: i32,
        changeset: AssignmentChangeset,
    ) -> Result<()> {
        // TODO: refactor
        let date1 = Local::now();
        let date2 = Local::now();

        query!("UPDATE assignment SET function = $1, startTimestamp = $2, endTimestamp = $3 WHERE eventId = $4 AND availabillityId = $5;", changeset.function as Function, date1, date2, event_id, availabillity_id).execute(pool).await?;

        Ok(())
    }

    pub async fn delete(pool: &PgPool, event_id: i32, availabillity_id: i32) -> Result<()> {
        query!("DELETE FROM assignment WHERE assignment.eventId = $1 AND assignment.availabillityId = $2;",
            event_id,
            availabillity_id
        )
        .execute(pool)
        .await?;
        Ok(())
    }
}