use anyhow::anyhow;
use rpc::{
    proto::{self},
    ConnectionId,
};
use sea_orm::{
    ActiveModelTrait, ActiveValue, ColumnTrait, Condition, DatabaseTransaction, EntityTrait,
    IntoActiveModel, ModelTrait, QueryFilter,
};

use crate::db::ProjectId;

use super::{
    dev_server, dev_server_project, project, project_collaborator, worktree, Database, DevServerId,
    DevServerProjectId, RejoinedProject, ResharedProject, ServerId, UserId,
};

impl Database {
    pub async fn get_dev_server_project(
        &self,
        dev_server_project_id: DevServerProjectId,
    ) -> crate::Result<dev_server_project::Model> {
        self.transaction(|tx| async move {
            Ok(
                dev_server_project::Entity::find_by_id(dev_server_project_id)
                    .one(&*tx)
                    .await?
                    .ok_or_else(|| {
                        anyhow!("no dev server project with id {}", dev_server_project_id)
                    })?,
            )
        })
        .await
    }

    pub async fn get_projects_for_dev_server(
        &self,
        dev_server_id: DevServerId,
    ) -> crate::Result<Vec<proto::DevServerProject>> {
        self.transaction(|tx| async move {
            self.get_projects_for_dev_server_internal(dev_server_id, &tx)
                .await
        })
        .await
    }

    pub async fn get_projects_for_dev_server_internal(
        &self,
        dev_server_id: DevServerId,
        tx: &DatabaseTransaction,
    ) -> crate::Result<Vec<proto::DevServerProject>> {
        let servers = dev_server_project::Entity::find()
            .filter(dev_server_project::Column::DevServerId.eq(dev_server_id))
            .find_also_related(project::Entity)
            .all(tx)
            .await?;
        Ok(servers
            .into_iter()
            .map(|(dev_server_project, project)| dev_server_project.to_proto(project))
            .collect())
    }

    pub async fn dev_server_project_ids_for_user(
        &self,
        user_id: UserId,
        tx: &DatabaseTransaction,
    ) -> crate::Result<Vec<DevServerProjectId>> {
        let dev_servers = dev_server::Entity::find()
            .filter(dev_server::Column::UserId.eq(user_id))
            .find_with_related(dev_server_project::Entity)
            .all(tx)
            .await?;

        Ok(dev_servers
            .into_iter()
            .flat_map(|(_, projects)| projects.into_iter().map(|p| p.id))
            .collect())
    }

    pub async fn owner_for_dev_server_project(
        &self,
        dev_server_project_id: DevServerProjectId,
        tx: &DatabaseTransaction,
    ) -> crate::Result<UserId> {
        let dev_server = dev_server_project::Entity::find_by_id(dev_server_project_id)
            .find_also_related(dev_server::Entity)
            .one(tx)
            .await?
            .and_then(|(_, dev_server)| dev_server)
            .ok_or_else(|| anyhow!("no dev server project"))?;

        Ok(dev_server.user_id)
    }

    pub async fn get_stale_dev_server_projects(
        &self,
        connection: ConnectionId,
    ) -> crate::Result<Vec<ProjectId>> {
        self.transaction(|tx| async move {
            let projects = project::Entity::find()
                .filter(
                    Condition::all()
                        .add(project::Column::HostConnectionId.eq(connection.id))
                        .add(project::Column::HostConnectionServerId.eq(connection.owner_id)),
                )
                .all(&*tx)
                .await?;

            Ok(projects.into_iter().map(|p| p.id).collect())
        })
        .await
    }

    pub async fn create_dev_server_project(
        &self,
        dev_server_id: DevServerId,
        path: &str,
        user_id: UserId,
    ) -> crate::Result<(dev_server_project::Model, proto::DevServerProjectsUpdate)> {
        self.transaction(|tx| async move {
            let dev_server = dev_server::Entity::find_by_id(dev_server_id)
                .one(&*tx)
                .await?
                .ok_or_else(|| anyhow!("no dev server with id {}", dev_server_id))?;
            if dev_server.user_id != user_id {
                return Err(anyhow!("not your dev server"))?;
            }

            let project = dev_server_project::Entity::insert(dev_server_project::ActiveModel {
                id: ActiveValue::NotSet,
                dev_server_id: ActiveValue::Set(dev_server_id),
                paths: ActiveValue::Set(dev_server_project::JSONPaths(vec![path.to_string()])),
            })
            .exec_with_returning(&*tx)
            .await?;

            let status = self
                .dev_server_projects_update_internal(user_id, &tx)
                .await?;

            Ok((project, status))
        })
        .await
    }

    pub async fn update_dev_server_project(
        &self,
        id: DevServerProjectId,
        paths: &[String],
        user_id: UserId,
    ) -> crate::Result<(dev_server_project::Model, proto::DevServerProjectsUpdate)> {
        self.transaction(move |tx| async move {
            let paths = paths.to_owned();
            let Some((project, Some(dev_server))) = dev_server_project::Entity::find_by_id(id)
                .find_also_related(dev_server::Entity)
                .one(&*tx)
                .await?
            else {
                return Err(anyhow!("no such dev server project"))?;
            };

            if dev_server.user_id != user_id {
                return Err(anyhow!("not your dev server"))?;
            }
            let mut project = project.into_active_model();
            project.paths = ActiveValue::Set(dev_server_project::JSONPaths(paths));
            let project = project.update(&*tx).await?;

            let status = self
                .dev_server_projects_update_internal(user_id, &tx)
                .await?;

            Ok((project, status))
        })
        .await
    }

    pub async fn delete_dev_server_project(
        &self,
        dev_server_project_id: DevServerProjectId,
        dev_server_id: DevServerId,
        user_id: UserId,
    ) -> crate::Result<(Vec<proto::DevServerProject>, proto::DevServerProjectsUpdate)> {
        self.transaction(|tx| async move {
            project::Entity::delete_many()
                .filter(project::Column::DevServerProjectId.eq(dev_server_project_id))
                .exec(&*tx)
                .await?;
            let result = dev_server_project::Entity::delete_by_id(dev_server_project_id)
                .exec(&*tx)
                .await?;
            if result.rows_affected != 1 {
                return Err(anyhow!(
                    "no dev server project with id {}",
                    dev_server_project_id
                ))?;
            }

            let status = self
                .dev_server_projects_update_internal(user_id, &tx)
                .await?;

            let projects = self
                .get_projects_for_dev_server_internal(dev_server_id, &tx)
                .await?;
            Ok((projects, status))
        })
        .await
    }

    pub async fn share_dev_server_project(
        &self,
        dev_server_project_id: DevServerProjectId,
        dev_server_id: DevServerId,
        connection: ConnectionId,
        worktrees: &[proto::WorktreeMetadata],
    ) -> crate::Result<(
        proto::DevServerProject,
        UserId,
        proto::DevServerProjectsUpdate,
    )> {
        self.transaction(|tx| async move {
            let dev_server = dev_server::Entity::find_by_id(dev_server_id)
                .one(&*tx)
                .await?
                .ok_or_else(|| anyhow!("no dev server with id {}", dev_server_id))?;

            let dev_server_project = dev_server_project::Entity::find_by_id(dev_server_project_id)
                .one(&*tx)
                .await?
                .ok_or_else(|| {
                    anyhow!("no dev server project with id {}", dev_server_project_id)
                })?;

            if dev_server_project.dev_server_id != dev_server_id {
                return Err(anyhow!("dev server project shared from wrong server"))?;
            }

            let project = project::ActiveModel {
                room_id: ActiveValue::Set(None),
                host_user_id: ActiveValue::Set(None),
                host_connection_id: ActiveValue::set(Some(connection.id as i32)),
                host_connection_server_id: ActiveValue::set(Some(ServerId(
                    connection.owner_id as i32,
                ))),
                id: ActiveValue::NotSet,
                hosted_project_id: ActiveValue::Set(None),
                dev_server_project_id: ActiveValue::Set(Some(dev_server_project_id)),
            }
            .insert(&*tx)
            .await?;

            if !worktrees.is_empty() {
                worktree::Entity::insert_many(worktrees.iter().map(|worktree| {
                    worktree::ActiveModel {
                        id: ActiveValue::set(worktree.id as i64),
                        project_id: ActiveValue::set(project.id),
                        abs_path: ActiveValue::set(worktree.abs_path.clone()),
                        root_name: ActiveValue::set(worktree.root_name.clone()),
                        visible: ActiveValue::set(worktree.visible),
                        scan_id: ActiveValue::set(0),
                        completed_scan_id: ActiveValue::set(0),
                    }
                }))
                .exec(&*tx)
                .await?;
            }

            let status = self
                .dev_server_projects_update_internal(dev_server.user_id, &tx)
                .await?;

            Ok((
                dev_server_project.to_proto(Some(project)),
                dev_server.user_id,
                status,
            ))
        })
        .await
    }

    pub async fn reshare_dev_server_projects(
        &self,
        reshared_projects: &Vec<proto::UpdateProject>,
        dev_server_id: DevServerId,
        connection: ConnectionId,
    ) -> crate::Result<Vec<ResharedProject>> {
        self.transaction(|tx| async move {
            let mut ret = Vec::new();
            for reshared_project in reshared_projects {
                let project_id = ProjectId::from_proto(reshared_project.project_id);
                let (project, dev_server_project) = project::Entity::find_by_id(project_id)
                    .find_also_related(dev_server_project::Entity)
                    .one(&*tx)
                    .await?
                    .ok_or_else(|| anyhow!("project does not exist"))?;

                if dev_server_project.map(|rp| rp.dev_server_id) != Some(dev_server_id) {
                    return Err(anyhow!("dev server project reshared from wrong server"))?;
                }

                let Ok(old_connection_id) = project.host_connection() else {
                    return Err(anyhow!("dev server project was not shared"))?;
                };

                project::Entity::update(project::ActiveModel {
                    id: ActiveValue::set(project_id),
                    host_connection_id: ActiveValue::set(Some(connection.id as i32)),
                    host_connection_server_id: ActiveValue::set(Some(ServerId(
                        connection.owner_id as i32,
                    ))),
                    ..Default::default()
                })
                .exec(&*tx)
                .await?;

                let collaborators = project
                    .find_related(project_collaborator::Entity)
                    .all(&*tx)
                    .await?;

                self.update_project_worktrees(project_id, &reshared_project.worktrees, &tx)
                    .await?;

                ret.push(super::ResharedProject {
                    id: project_id,
                    old_connection_id,
                    collaborators: collaborators
                        .iter()
                        .map(|collaborator| super::ProjectCollaborator {
                            connection_id: collaborator.connection(),
                            user_id: collaborator.user_id,
                            replica_id: collaborator.replica_id,
                            is_host: collaborator.is_host,
                        })
                        .collect(),
                    worktrees: reshared_project.worktrees.clone(),
                });
            }
            Ok(ret)
        })
        .await
    }

    pub async fn rejoin_dev_server_projects(
        &self,
        rejoined_projects: &Vec<proto::RejoinProject>,
        user_id: UserId,
        connection_id: ConnectionId,
    ) -> crate::Result<Vec<RejoinedProject>> {
        self.transaction(|tx| async move {
            let mut ret = Vec::new();
            for rejoined_project in rejoined_projects {
                if let Some(project) = self
                    .rejoin_project_internal(&tx, rejoined_project, user_id, connection_id)
                    .await?
                {
                    ret.push(project);
                }
            }
            Ok(ret)
        })
        .await
    }
}