use std::path::PathBuf;

use iced::{
        executor,
        widget::{button, text, text_input, Button, Column, Row},
        Application, Command, Length, Theme,
};

use crate::{
        general::app_directory,
        git_handling::{save, Repository, UpdateError},
};

#[derive(Debug, Clone)]
pub enum Message {
        NewRepoFormRequested,
        NewRepoFormChanged(RepoRequest),
        UpdateRepository(usize),
        DeleteRepo(usize),
        RepoUpdated(Result<(), UpdateError>),
        FilesLoaded(Vec<Repository>),
        SaveRequested,
        SaveFinished,
        NewRepoFormSubmitted,
}

#[derive(Clone, Debug)]
pub struct RepoRequest {
        name: String,
        branch: String,
        clone_path: String,
        install_script: String,
        remote_name: String,
        extra_info: String,
}

impl Default for RepoRequest {
        fn default() -> Self {
                RepoRequest {
                        name: String::from(""),
                        branch: String::from("master"),
                        clone_path: String::from(""),
                        install_script: String::from(""),
                        remote_name: String::from(""),
                        extra_info: String::from(""),
                }
        }
}

#[derive(Clone, Debug)]
pub struct GitPullD {
        pub repositories: Vec<Repository>,
        pub app_directory: PathBuf,
        new_repo_request: Option<RepoRequest>,
}

impl Application for GitPullD {
        type Message = Message;
        type Theme = Theme;
        type Flags = ();
        type Executor = executor::Default;

        fn new(_flags: Self::Flags) -> (Self, iced::Command<Self::Message>) {
                (
                        Self {
                                app_directory: app_directory(),
                                repositories: crate::git_handling::load(app_directory()),
                                new_repo_request: None,
                        },
                        Command::none(),
                )
        }
        fn title(&self) -> String {
                String::from("GitPullD")
        }
        fn update(&mut self, message: Self::Message) -> iced::Command<Self::Message> {
                match message {
                        Message::UpdateRepository(index) => {
                                let curr_repo = self.repositories[index].clone();
                                Command::perform(crate::git_handling::update(curr_repo), Message::RepoUpdated)
                        }
                        Message::FilesLoaded(mut vector) => {
                                self.repositories.append(&mut vector);
                                Command::none()
                        }
                        Message::SaveRequested => Command::perform(save(self.clone()), |_| Message::SaveFinished),
                        Message::NewRepoFormRequested => {
                                self.new_repo_request = Some(RepoRequest::default());
                                Command::none()
                        }
                        Message::NewRepoFormChanged(request) => {
                                self.new_repo_request = Some(request);
                                Command::none()
                        }
                        Message::NewRepoFormSubmitted => {
                                todo!()
                        }
                        _ => Command::none(),
                }
        }
        fn view(&self) -> iced::Element<'_, Self::Message, Self::Theme, iced::Renderer> {
                let repos = &self.repositories;
                let mut column = vec![];

                if let Some(repo_request) = &self.new_repo_request {
                        column.extend([
                                text_input("Name of Repository", &repo_request.name)
                                        .on_input(|name| {
                                                Message::NewRepoFormChanged(RepoRequest {
                                                        name,
                                                        ..repo_request.clone()
                                                })
                                        })
                                        .width(Length::Fill)
                                        .into(),
                                text_input("Path to cloned repo", &repo_request.clone_path)
                                        .on_input(|clone_path| {
                                                Message::NewRepoFormChanged(RepoRequest {
                                                        clone_path,
                                                        ..repo_request.clone()
                                                })
                                        })
                                        .width(Length::Fill)
                                        .into(),
                                text_input("Path to install script", &repo_request.install_script)
                                        .on_input(|install_script| {
                                                Message::NewRepoFormChanged(RepoRequest {
                                                        install_script,
                                                        ..repo_request.clone()
                                                })
                                        })
                                        .width(Length::Fill)
                                        .into(),
                                text_input("Name of Remote", &repo_request.remote_name)
                                        .on_input(|remote_name| {
                                                Message::NewRepoFormChanged(RepoRequest {
                                                        remote_name,
                                                        ..repo_request.clone()
                                                })
                                        })
                                        .width(Length::Fill)
                                        .into(),
                                text_input("Name of Branch", &repo_request.branch)
                                        .on_input(|branch| {
                                                Message::NewRepoFormChanged(RepoRequest {
                                                        branch,
                                                        ..repo_request.clone()
                                                })
                                        })
                                        .width(Length::Fill)
                                        .into(),
                                text_input("Extra info", &repo_request.extra_info)
                                        .on_input(|extra_info| {
                                                Message::NewRepoFormChanged(RepoRequest {
                                                        extra_info,
                                                        ..repo_request.clone()
                                                })
                                        })
                                        .width(Length::Fill)
                                        .into(),
                                Button::new("submit").on_press(Message::NewRepoFormSubmitted).into(),
                        ]);
                } else {
                        column.push(button("new repo").on_press(Message::NewRepoFormRequested).into());
                }

                for (i, repo) in repos.iter().enumerate() {
                        let name = text(repo.repo_name()).into();
                        let update_button = button("update").on_press(Message::UpdateRepository(i));

                        column.push(Row::from_vec(vec![name, update_button.into()]).into());
                }

                column.push(button("save").on_press(Message::SaveRequested).into());

                Into::<iced::Element<'_, Self::Message, Self::Theme, iced::Renderer>>::into(Column::from_vec(column))
        }
        fn theme(&self) -> Self::Theme {
                Theme::GruvboxDark
        }
}