//! Contains all the actions that can be broadcasted via [`crate::sse::broadcaster::Broadcaster`].

// The properties of the actions are not documented because they are
// self-explanatory and should be already documented in the respective
// entity DTOs.
#![allow(clippy::missing_docs_in_private_items)]
// Don't make the `new` functions const, there might come more fields in the future.
#![allow(clippy::missing_const_for_fn)]

use chrono::NaiveDate;
use postgis_diesel::types::{Point, Polygon};
use serde::Serialize;
use typeshare::typeshare;
use uuid::Uuid;

use crate::model::dto::{
    areas::{AreaDto, AreaKind, AreaType},
    base_layer_images::BaseLayerImageDto,
    drawings::DrawingDto,
    layers::{LayerDto, LayerRenameDto},
    plantings::{
        DeletePlantingDto, MovePlantingDto, PlantingDto, TransformPlantingDto,
        UpdateAddDatePlantingDto, UpdatePlantingNoteDto, UpdateRemoveDatePlantingDto,
    },
    UpdateMapGeometryDto,
};

#[typeshare]
#[derive(Debug, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Action {
    pub action_id: Uuid,
    pub user_id: Uuid,
    pub action: ActionType,
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
// Use the name of the enum variant as the type field looking like { "type": "CreatePlanting", ... }.
/// An enum representing all the actions that can be broadcasted via [`crate::sse::broadcaster::Broadcaster`].
#[serde(tag = "type", content = "payload")]
pub enum ActionType {
    /// An action used to broadcast creation of a layer.
    CreateLayer(LayerDto),
    /// An action used to broadcast soft-deletion of a layer.
    /// Deleted layers can be restored.
    DeleteLayer(Uuid),
    /// An action used to broadcast restoration of a deleted layer.
    /// Restore is only supported for drawing layers
    RestoreDrawingLayer(RestoreDrawingLayerActionPayload),
    /// An action used to broadcast the renaming of a layer.
    RenameLayer(LayerRenameDto),
    /// An action used to broadcast the reordering of multiple layers.
    ReorderLayers(Vec<Uuid>),

    /// An action used to broadcast creation of plantings.
    CreatePlanting(Vec<PlantingDto>),
    /// An action used to broadcast deletion of plantings.
    DeletePlanting(Vec<DeletePlantingActionPayload>),
    /// An action used to broadcast movement of plantings.
    MovePlanting(Vec<MovePlantingActionPayload>),
    /// An action used to broadcast transformation of plantings.
    TransformPlanting(Vec<TransformPlantingActionPayload>),
    /// An action used to update the `add_date` of plantings.
    UpdatePlantingAddDate(Vec<UpdateAddDateActionPayload>),
    /// An action used to update the `remove_date` of plantings.
    UpdatePlantingRemoveDate(Vec<UpdateRemoveDateActionPayload>),
    /// An action used to broadcast updating Markdown notes of plantings.
    UpdatePlantingNotes(Vec<UpdatePlantingNotesActionPayload>),

    /// An action used to broadcast creation of shading.
    CreateShading(Vec<AreaDto>),
    /// An action used to broadcast deletion of shading.
    DeleteShading(Vec<Uuid>),
    /// An action used to broadcast change of shading.
    UpdateShading(Vec<UpdateAreaActionPayload>),
    /// An action used to update `add_date` of shading.
    UpdateShadingAddDate(Vec<UpdateAreaAddDateActionPayload>),
    /// An action used to update `remove_date` of shading.
    UpdateShadingRemoveDate(Vec<UpdateAreaRemoveDateActionPayload>),
    /// An action used to update `notes` of shading.
    UpdateShadingNotes(Vec<UpdateAreaNotesActionPayload>),

    /// An action used to broadcast creation of hydrology.
    CreateHydrology(Vec<AreaDto>),
    /// An action used to broadcast deletion of hydrology.
    DeleteHydrology(Vec<Uuid>),
    /// An action used to broadcast change of hydrology.
    UpdateHydrology(Vec<UpdateAreaActionPayload>),
    /// An action used to update `add_date` of hydrology.
    UpdateHydrologyAddDate(Vec<UpdateAreaAddDateActionPayload>),
    /// An action used to update `remove_date` of hydrology.
    UpdateHydrologyRemoveDate(Vec<UpdateAreaRemoveDateActionPayload>),
    /// An action used to update `notes` of hydrology.
    UpdateHydrologyNotes(Vec<UpdateAreaNotesActionPayload>),

    /// An action used to broadcast creation of soil texture.
    CreateSoilTexture(Vec<AreaDto>),
    /// An action used to broadcast deletion of soil texture.
    DeleteSoilTexture(Vec<Uuid>),
    /// An action used to broadcast change of soil texture.
    UpdateSoilTexture(Vec<UpdateAreaActionPayload>),
    /// An action used to update `add_date` of soil texture.
    UpdateSoilTextureAddDate(Vec<UpdateAreaAddDateActionPayload>),
    /// An action used to update `remove_date` of soil texture.
    UpdateSoilTextureRemoveDate(Vec<UpdateAreaRemoveDateActionPayload>),
    /// An action used to update `notes` of soil texture.
    UpdateSoilTextureNotes(Vec<UpdateAreaNotesActionPayload>),

    /// An action used to broadcast creation of a baseLayerImage.
    CreateBaseLayerImage(CreateBaseLayerImageActionPayload),
    /// An action used to broadcast update of a baseLayerImage.
    UpdateBaseLayerImage(UpdateBaseLayerImageActionPayload),
    /// An action used to broadcast deletion of a baseLayerImage.
    DeleteBaseLayerImage(DeleteBaseLayerImageActionPayload),
    /// An action used to broadcast an update to the map geometry.
    UpdateMapGeometry(UpdateMapGeometryActionPayload),
    /// An action used to update `additional_name` of one planting.
    UpdatePlantingAdditionalName(UpdatePlantingAdditionalNamePayload),

    /// An action used to broadcast creation of new drawings.
    CreateDrawing(Vec<DrawingDto>),
    /// An action used to broadcast deletion of an existing drawings.
    DeleteDrawing(Vec<Uuid>),
    /// An action used to broadcast arbitrary updates of existing drawings.
    UpdateDrawing(Vec<DrawingDto>),
    /// An action used to broadcast the update of `add_date` of existing drawings.
    UpdateDrawingAddDate(Vec<DrawingDto>),
    /// An action used to broadcast the update of `remove_date` of existing drawings.
    UpdateDrawingRemoveDate(Vec<DrawingDto>),
    /// An action used to broadcast the update of `notes` of existing drawings.
    UpdateDrawingNotes(Vec<UpdateDrawingNotesActionPayload>),
}

impl Action {
    #[must_use]
    pub fn new_create_planting_action(
        dtos: Vec<PlantingDto>,
        user_id: Uuid,
        action_id: Uuid,
    ) -> Self {
        Self {
            action_id,
            user_id,
            action: ActionType::CreatePlanting(dtos),
        }
    }

    #[must_use]
    pub fn new_delete_planting_action(
        dtos: &[DeletePlantingDto],
        user_id: Uuid,
        action_id: Uuid,
    ) -> Self {
        Self {
            action_id,
            user_id,
            action: ActionType::DeletePlanting(
                dtos.iter()
                    .map(|dto| DeletePlantingActionPayload { id: dto.id })
                    .collect(),
            ),
        }
    }

    #[must_use]
    pub fn new_move_planting_action(
        dtos: &[MovePlantingDto],
        user_id: Uuid,
        action_id: Uuid,
    ) -> Self {
        Self {
            action_id,
            user_id,
            action: ActionType::MovePlanting(
                dtos.iter()
                    .map(|dto| MovePlantingActionPayload {
                        id: dto.id,
                        x: dto.x,
                        y: dto.y,
                    })
                    .collect(),
            ),
        }
    }

    #[must_use]
    pub fn new_transform_planting_action(
        dtos: &[TransformPlantingDto],
        user_id: Uuid,
        action_id: Uuid,
    ) -> Self {
        Self {
            action_id,
            user_id,
            action: ActionType::TransformPlanting(
                dtos.iter()
                    .map(|dto| TransformPlantingActionPayload {
                        id: dto.id,
                        x: dto.x,
                        y: dto.y,
                        rotation: dto.rotation,
                        size_x: dto.size_x,
                        size_y: dto.size_y,
                        height: dto.height,
                    })
                    .collect(),
            ),
        }
    }

    #[must_use]
    pub fn new_update_planting_add_date_action(
        dtos: &[UpdateAddDatePlantingDto],
        user_id: Uuid,
        action_id: Uuid,
    ) -> Self {
        Self {
            action_id,
            user_id,
            action: ActionType::UpdatePlantingAddDate(
                dtos.iter()
                    .map(|dto| UpdateAddDateActionPayload {
                        id: dto.id,
                        add_date: dto.add_date,
                    })
                    .collect(),
            ),
        }
    }

    #[must_use]
    pub fn new_update_planting_remove_date_action(
        dtos: &[UpdateRemoveDatePlantingDto],
        user_id: Uuid,
        action_id: Uuid,
    ) -> Self {
        Self {
            action_id,
            user_id,
            action: ActionType::UpdatePlantingRemoveDate(
                dtos.iter()
                    .map(|dto| UpdateRemoveDateActionPayload {
                        id: dto.id,
                        remove_date: dto.remove_date,
                    })
                    .collect(),
            ),
        }
    }

    #[must_use]
    pub fn new_update_planting_note_action(
        dtos: &[UpdatePlantingNoteDto],
        user_id: Uuid,
        action_id: Uuid,
    ) -> Self {
        Self {
            action_id,
            user_id,
            action: ActionType::UpdatePlantingNotes(
                dtos.iter()
                    .map(|dto| UpdatePlantingNotesActionPayload {
                        id: dto.id,
                        notes: dto.notes.clone(),
                    })
                    .collect(),
            ),
        }
    }

    #[must_use]
    pub fn new_create_area_action(
        area_kind: AreaKind,
        dtos: Vec<AreaDto>,
        user_id: Uuid,
        action_id: Uuid,
    ) -> Self {
        Self {
            action_id,
            user_id,
            action: match area_kind {
                AreaKind::Shade => ActionType::CreateShading(dtos),
                AreaKind::Hydrology => ActionType::CreateHydrology(dtos),
                AreaKind::SoilTexture => ActionType::CreateSoilTexture(dtos),
            },
        }
    }

    #[must_use]
    pub fn new_update_area_action(
        area_kind: AreaKind,
        dtos: &[AreaDto],
        user_id: Uuid,
        action_id: Uuid,
    ) -> Self {
        let payload = dtos
            .iter()
            .map(|dto| UpdateAreaActionPayload {
                id: dto.id,
                area_type: dto.area_type.clone(),
            })
            .collect();
        Self {
            action_id,
            user_id,
            action: match area_kind {
                AreaKind::Shade => ActionType::UpdateShading(payload),
                AreaKind::Hydrology => ActionType::UpdateHydrology(payload),
                AreaKind::SoilTexture => ActionType::UpdateSoilTexture(payload),
            },
        }
    }

    #[must_use]
    pub fn new_update_area_add_date_action(
        area_kind: AreaKind,
        dtos: &[AreaDto],
        user_id: Uuid,
        action_id: Uuid,
    ) -> Self {
        let payload = dtos
            .iter()
            .map(|dto| UpdateAreaAddDateActionPayload {
                id: dto.id,
                add_date: dto.add_date,
            })
            .collect();
        Self {
            action_id,
            user_id,
            action: match area_kind {
                AreaKind::Shade => ActionType::UpdateShadingAddDate(payload),
                AreaKind::Hydrology => ActionType::UpdateHydrologyAddDate(payload),
                AreaKind::SoilTexture => ActionType::UpdateSoilTextureAddDate(payload),
            },
        }
    }

    #[must_use]
    pub fn new_update_area_remove_date_action(
        area_kind: AreaKind,
        dtos: &[AreaDto],
        user_id: Uuid,
        action_id: Uuid,
    ) -> Self {
        let payload = dtos
            .iter()
            .map(|dto| UpdateAreaRemoveDateActionPayload {
                id: dto.id,
                remove_date: dto.remove_date,
            })
            .collect();
        Self {
            action_id,
            user_id,
            action: match area_kind {
                AreaKind::Shade => ActionType::UpdateShadingRemoveDate(payload),
                AreaKind::Hydrology => ActionType::UpdateHydrologyRemoveDate(payload),
                AreaKind::SoilTexture => ActionType::UpdateSoilTextureRemoveDate(payload),
            },
        }
    }

    #[must_use]
    pub fn new_update_area_notes_action(
        area_kind: AreaKind,
        dtos: &[AreaDto],
        user_id: Uuid,
        action_id: Uuid,
    ) -> Self {
        let payload: Vec<UpdateAreaNotesActionPayload> = dtos
            .iter()
            .map(|dto| UpdateAreaNotesActionPayload {
                id: dto.id,
                notes: dto.notes.clone(),
            })
            .collect();
        Self {
            action_id,
            user_id,
            action: match area_kind {
                AreaKind::Shade => ActionType::UpdateShadingNotes(payload),
                AreaKind::Hydrology => ActionType::UpdateHydrologyNotes(payload),
                AreaKind::SoilTexture => ActionType::UpdateSoilTextureNotes(payload),
            },
        }
    }

    #[must_use]
    pub fn new_delete_area_action(
        area_kind: AreaKind,
        ids: Vec<Uuid>,
        user_id: Uuid,
        action_id: Uuid,
    ) -> Self {
        Self {
            action_id,
            user_id,
            action: match area_kind {
                AreaKind::Shade => ActionType::DeleteShading(ids),
                AreaKind::Hydrology => ActionType::DeleteHydrology(ids),
                AreaKind::SoilTexture => ActionType::DeleteSoilTexture(ids),
            },
        }
    }
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::RestoreDrawingLayer`].
#[serde(rename_all = "camelCase")]
pub struct RestoreDrawingLayerActionPayload {
    // ID of the layer
    id: Uuid,
    // Drawings saved on that layer
    drawings: Vec<DrawingDto>,
}

impl RestoreDrawingLayerActionPayload {
    #[must_use]
    pub fn new(id: Uuid, drawings: Vec<DrawingDto>) -> Self {
        Self { id, drawings }
    }
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::CreatePlanting`].
/// This struct should always match [`PlantingDto`].
#[serde(rename_all = "camelCase")]
pub struct CreatePlantActionPayload {
    id: Uuid,
    layer_id: Uuid,
    plant_id: i32,
    x: i32,
    y: i32,
    rotation: f32,
    size_x: i32,
    size_y: i32,
    height: Option<i32>,
    add_date: Option<NaiveDate>,
    remove_date: Option<NaiveDate>,
    seed_id: Option<i32>,
    additional_name: Option<String>,
    is_area: bool,
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::DeletePlanting`].
#[serde(rename_all = "camelCase")]
pub struct DeletePlantingActionPayload {
    id: Uuid,
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::MovePlanting`].
#[serde(rename_all = "camelCase")]
pub struct MovePlantingActionPayload {
    id: Uuid,
    x: i32,
    y: i32,
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::TransformPlanting`].
#[serde(rename_all = "camelCase")]
pub struct TransformPlantingActionPayload {
    id: Uuid,
    x: i32,
    y: i32,
    rotation: f32,
    size_x: i32,
    size_y: i32,
    height: Option<i32>,
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct CreateShadingActionPayload {
    id: Uuid,
    layer_id: Uuid,
    area_type: AreaType,
    geometry: Polygon<Point>,
    add_date: Option<NaiveDate>,
    remove_date: Option<NaiveDate>,
    notes: String,
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct CreateHydrologyActionPayload {
    id: Uuid,
    layer_id: Uuid,
    area_type: AreaType,
    geometry: Polygon<Point>,
    add_date: Option<NaiveDate>,
    remove_date: Option<NaiveDate>,
    notes: String,
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct CreateAreaActionPayload {
    id: Uuid,
    layer_id: Uuid,
    area_type: AreaType,
    geometry: Polygon<Point>,
    add_date: Option<NaiveDate>,
    remove_date: Option<NaiveDate>,
    notes: String,
}

impl CreateAreaActionPayload {
    #[must_use]
    pub fn new(payload: AreaDto) -> Self {
        Self {
            id: payload.id,
            layer_id: payload.layer_id,
            area_type: payload.area_type,
            geometry: payload.geometry,
            add_date: payload.add_date,
            remove_date: payload.remove_date,
            notes: payload.notes,
        }
    }
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of [`ActionType::UpdateShading`, `ActionType::UpdateHydrology`, `ActionType::UpdateSoilTexture`].
#[serde(rename_all = "camelCase")]
pub struct UpdateAreaActionPayload {
    id: Uuid,
    area_type: AreaType,
}

impl UpdateAreaActionPayload {
    #[must_use]
    pub fn new(payload: AreaDto) -> Self {
        Self {
            id: payload.id,
            area_type: payload.area_type,
        }
    }
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::UpdateShadingAddDate`, `ActionType::UpdateHydrologyAddDate`, `ActionType::UpdateSoilTextureAddDate`].
#[serde(rename_all = "camelCase")]
pub struct UpdateAreaAddDateActionPayload {
    id: Uuid,
    add_date: Option<NaiveDate>,
}

impl UpdateAreaAddDateActionPayload {
    #[must_use]
    pub fn new(payload: &AreaDto) -> Self {
        Self {
            id: payload.id,
            add_date: payload.add_date,
        }
    }
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::UpdateShadingRemoveDate`, `ActionType::UpdateHydrologyRemoveDate`, `ActionType::UpdateSoilTextureRemoveDate`].
#[serde(rename_all = "camelCase")]
pub struct UpdateAreaRemoveDateActionPayload {
    id: Uuid,
    remove_date: Option<NaiveDate>,
}

impl UpdateAreaRemoveDateActionPayload {
    #[must_use]
    pub fn new(payload: &AreaDto) -> Self {
        Self {
            id: payload.id,
            remove_date: payload.remove_date,
        }
    }
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::UpdateShadingNotes`, `ActionType::UpdateHydrologyNotes`, `ActionType::UpdateSoilTextureNotes`].
pub struct UpdateAreaNotesActionPayload {
    id: Uuid,
    notes: String,
}

impl UpdateAreaNotesActionPayload {
    #[must_use]
    pub fn new(payload: &AreaDto) -> Self {
        Self {
            id: payload.id,
            notes: payload.notes.clone(),
        }
    }
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::UpdatePlantingNotes`].
#[serde(rename_all = "camelCase")]
pub struct UpdatePlantingNotesActionPayload {
    id: Uuid,
    notes: String,
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::CreateBaseLayerImage`].
/// This struct should always match [`BaseLayerImageDto`].
#[serde(rename_all = "camelCase")]
pub struct CreateBaseLayerImageActionPayload {
    id: Uuid,
    layer_id: Uuid,
    rotation: f32,
    scale: f32,
    path: String,
}

impl CreateBaseLayerImageActionPayload {
    #[must_use]
    pub fn new(payload: BaseLayerImageDto) -> Self {
        Self {
            id: payload.id,
            layer_id: payload.layer_id,
            rotation: payload.rotation,
            scale: payload.scale,
            path: payload.path,
        }
    }
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::DeleteBaseLayerImage`].
#[serde(rename_all = "camelCase")]
pub struct DeleteBaseLayerImageActionPayload {
    id: Uuid,
}

impl DeleteBaseLayerImageActionPayload {
    #[must_use]
    pub fn new(id: Uuid) -> Self {
        Self { id }
    }
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::UpdateBaseLayerImage`].
#[serde(rename_all = "camelCase")]
pub struct UpdateBaseLayerImageActionPayload {
    id: Uuid,
    layer_id: Uuid,
    rotation: f32,
    scale: f32,
    path: String,
    x: i32,
    y: i32,
}

impl UpdateBaseLayerImageActionPayload {
    #[must_use]
    pub fn new(payload: BaseLayerImageDto) -> Self {
        Self {
            id: payload.id,
            layer_id: payload.layer_id,
            rotation: payload.rotation,
            scale: payload.scale,
            path: payload.path,
            x: payload.x,
            y: payload.y,
        }
    }
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the actions [`ActionType::UpdatePlantingAddDate]`].
#[serde(rename_all = "camelCase")]
pub struct UpdateAddDateActionPayload {
    id: Uuid,
    add_date: Option<NaiveDate>,
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::UpdatePlantingRemoveDate`].
#[serde(rename_all = "camelCase")]
pub struct UpdateRemoveDateActionPayload {
    id: Uuid,
    remove_date: Option<NaiveDate>,
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::UpdateMapGeometry`].
#[serde(rename_all = "camelCase")]
pub struct UpdateMapGeometryActionPayload {
    /// The entity id for this action.
    map_id: i32,
    // E.g. `{"rings": [[{"x": 0.0,"y": 0.0},{"x": 1000.0,"y": 0.0},{"x": 1000.0,"y": 1000.0},{"x": 0.0,"y": 1000.0},{"x": 0.0,"y": 0.0}]],"srid": 4326}`
    #[typeshare(serialized_as = "object")]
    geometry: Polygon<Point>,
}

impl UpdateMapGeometryActionPayload {
    #[must_use]
    pub fn new(payload: UpdateMapGeometryDto, map_id: i32) -> Self {
        Self {
            map_id,
            geometry: payload.geometry,
        }
    }
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::UpdatePlantingRemoveDate`].
#[serde(rename_all = "camelCase")]
pub struct UpdatePlantingAdditionalNamePayload {
    id: Uuid,
    additional_name: Option<String>,
}

impl UpdatePlantingAdditionalNamePayload {
    #[must_use]
    pub fn new(payload: &PlantingDto, new_additional_name: Option<String>) -> Self {
        Self {
            id: payload.id,
            additional_name: new_additional_name,
        }
    }
}

#[typeshare]
#[derive(Debug, Serialize, Clone)]
/// The payload of the [`ActionType::UpdatePlantingNotes`].
#[serde(rename_all = "camelCase")]
pub struct UpdateDrawingNotesActionPayload {
    id: Uuid,
    notes: String,
}

impl UpdateDrawingNotesActionPayload {
    #[must_use]
    pub fn new(drawing: DrawingDto) -> Self {
        Self {
            id: drawing.id,
            notes: drawing.notes,
        }
    }
}