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

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

pub struct Assignment {
    pub event_id: i32,
    pub availability_id: i32,
    pub function: Function,
    pub start: NaiveDateTime,
    pub end: NaiveDateTime,
}

impl Assignment {
    pub async fn create(
        pool: &PgPool,
        event_id: i32,
        availability_id: i32,
        changeset: AssignmentChangeset,
    ) -> Result<()> {
        query!(
            r##"
                INSERT INTO assignment (eventId, availabilityId, function, startTimestamp, endTimestamp)
                VALUES ($1, $2, $3, $4, $5);
            "##,
            event_id,
            availability_id,
            changeset.function as Function,
            changeset.time.0.and_utc(),
            changeset.time.1.and_utc()
        )
        .execute(pool)
        .await?;

        Ok(())
    }

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

        let assignemnets = records
            .iter()
            .map(|r| Assignment {
                event_id: r.eventid,
                availability_id: r.availabilityid,
                function: r.function,
                start: r.starttimestamp.naive_utc(),
                end: r.endtimestamp.naive_utc(),
            })
            .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.availabilityId,
                    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,
                availability_id: r.availabilityid,
                function: r.function,
                start: r.starttimestamp.naive_utc(),
                end: r.endtimestamp.naive_utc(),
            })
            .collect();

        Ok(assignemnets)
    }

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

        let assignemnet = record.map(|r| Assignment {
            event_id: r.eventid,
            availability_id: r.availabilityid,
            function: r.function,
            start: r.starttimestamp.naive_utc(),
            end: r.endtimestamp.naive_utc(),
        });

        Ok(assignemnet)
    }

    pub async fn update(
        pool: &PgPool,
        event_id: i32,
        availability_id: i32,
        changeset: AssignmentChangeset,
    ) -> Result<()> {
        query!("UPDATE assignment SET function = $1, startTimestamp = $2, endTimestamp = $3 WHERE eventId = $4 AND availabilityId = $5;", changeset.function as Function, changeset.time.0.and_utc(), changeset.time.1.and_utc(), event_id, availability_id).execute(pool).await?;

        Ok(())
    }

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