use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

/// Baseline resolution strategy for workspace branching.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum BaselineMode {
    /// Workspaces branch from the current HEAD of `integration_branch`.
    IntegrationHead,
    /// Workspaces branch from the latest release deployed to the canonical environment.
    /// Falls back to integration branch HEAD when no release exists.
    CanonicalEnvRelease,
}

impl Default for BaselineMode {
    fn default() -> Self {
        Self::CanonicalEnvRelease
    }
}

/// Per-app commit strategy controlling when workspace edits become Git commits.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CommitMode {
    /// Autosave to workspace working state; single commit created on submit.
    SubmitCommit,
    /// User-triggered checkpoints become individual commits.
    ManualCheckpoint,
}

impl Default for CommitMode {
    fn default() -> Self {
        Self::SubmitCommit
    }
}

/// App-level settings that control workspace and changeset behavior.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AppSettings {
    pub baseline_mode: BaselineMode,
    /// References an Environment id. None until first environment is created.
    pub canonical_env_id: Option<String>,
    pub commit_mode_default: CommitMode,
    /// Glob patterns that cannot be edited via workspace file operations.
    pub blocked_paths: Vec<String>,
    /// Maximum file size in bytes that can be written to a workspace (default 5 MB).
    pub file_size_limit_bytes: u64,
}

impl Default for AppSettings {
    fn default() -> Self {
        Self {
            baseline_mode: BaselineMode::default(),
            canonical_env_id: None,
            commit_mode_default: CommitMode::default(),
            blocked_paths: vec![
                ".git/**".to_string(),
                ".gitignore".to_string(),
                ".github/**".to_string(),
            ],
            file_size_limit_bytes: 5 * 1024 * 1024, // 5 MB
        }
    }
}

/// A managed configuration repository. One App = one Git repo.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct App {
    /// MongoDB ObjectId hex string.
    pub id: String,
    /// Human-readable app name (unique).
    pub name: String,
    /// Gitaly-relative path to the repository (e.g. "conman/my-app.git").
    pub repo_path: String,
    /// Integration branch name. Defaults to "main" in v1.
    pub integration_branch: String,
    /// Embedded settings document.
    pub settings: AppSettings,
    /// User who created the app.
    pub created_by: String,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RuntimeProfileKind {
    PersistentEnv,
    TempWorkspace,
    TempChangeset,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", content = "value", rename_all = "snake_case")]
pub enum EnvVarValue {
    String(String),
    Number(f64),
    Boolean(bool),
    Json(serde_json::Value),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RuntimeProfile {
    pub id: String,
    pub app_id: String,
    pub name: String,
    pub kind: RuntimeProfileKind,
    pub base_url: String,
    pub env_vars: std::collections::BTreeMap<String, EnvVarValue>,
    pub secrets_encrypted: std::collections::BTreeMap<String, String>,
    pub database_engine: String, // mongodb in v1
    pub connection_ref: String,
    pub provisioning_mode: String,
    pub base_profile_id: Option<String>,
    pub migration_paths: Vec<String>,
    pub migration_command: Option<String>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

/// A deploy target stage within an app's promotion pipeline.
/// Environments are ordered by `position` (0-based, lower = earlier stage).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Environment {
    /// MongoDB ObjectId hex string.
    pub id: String,
    pub app_id: String,
    /// Unique within the app (e.g. "Development", "QA", "UAT", "Production").
    pub name: String,
    /// 0-based position in the promotion pipeline.
    pub position: u32,
    /// True for the canonical user-facing environment used in baseline calculations.
    /// Exactly one environment per app may be canonical.
    pub is_canonical: bool,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

use serde::{Deserialize, Serialize};

// ── App CRUD ──

#[derive(Debug, Deserialize)]
pub struct CreateAppRequest {
    /// Human-readable name (must be unique).
    pub name: String,
    /// Gitaly-relative repository path. Verified to exist (or optionally created).
    pub repo_path: String,
}

#[derive(Debug, Serialize)]
pub struct AppResponse {
    pub id: String,
    pub name: String,
    pub repo_path: String,
    pub integration_branch: String,
    pub settings: AppSettingsResponse,
    pub created_by: String,
    pub created_at: String,
    pub updated_at: String,
}

#[derive(Debug, Serialize)]
pub struct AppSettingsResponse {
    pub baseline_mode: String,
    pub canonical_env_id: Option<String>,
    pub commit_mode_default: String,
    pub blocked_paths: Vec<String>,
    pub file_size_limit_bytes: u64,
}

// ── Settings ──

#[derive(Debug, Deserialize)]
pub struct UpdateAppSettingsRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub baseline_mode: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub canonical_env_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub commit_mode_default: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub blocked_paths: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file_size_limit_bytes: Option<u64>,
}

// ── Environments ──

#[derive(Debug, Deserialize)]
pub struct CreateEnvironmentRequest {
    pub name: String,
    pub position: u32,
    #[serde(default)]
    pub is_canonical: bool,
}

#[derive(Debug, Deserialize)]
pub struct UpdateEnvironmentsRequest {
    /// Full ordered list of environments. Replaces all positions in one call.
    pub environments: Vec<EnvironmentEntry>,
}

#[derive(Debug, Deserialize)]
pub struct EnvironmentEntry {
    pub id: String,
    pub name: String,
    pub position: u32,
    pub is_canonical: bool,
}

#[derive(Debug, Serialize)]
pub struct EnvironmentResponse {
    pub id: String,
    pub app_id: String,
    pub name: String,
    pub position: u32,
    pub is_canonical: bool,
    pub created_at: String,
    pub updated_at: String,
}

// ── Membership ──

#[derive(Debug, Serialize)]
pub struct MemberResponse {
    pub user_id: String,
    pub email: String,
    pub role: String,
    pub joined_at: String,
}

#[derive(Debug, Deserialize)]
pub struct UpdateMemberRoleRequest {
    pub role: String,
}

// Unique app name
{ "name": 1 }  // unique: true

// Unique repo path (one app per repo)
{ "repo_path": 1 }  // unique: true

{
  "_id": ObjectId("664f1a2b3c4d5e6f70809010"),
  "name": "payments-config",
  "repo_path": "conman/payments-config.git",
  "integration_branch": "main",
  "settings": {
    "baseline_mode": "canonical_env_release",
    "canonical_env_id": ObjectId("664f1a2b3c4d5e6f70809020"),
    "commit_mode_default": "submit_commit",
    "blocked_paths": [".git/**", ".gitignore", ".github/**"],
    "file_size_limit_bytes": 5242880
  },
  "created_by": ObjectId("664f1a2b3c4d5e6f70809001"),
  "created_at": ISODate("2025-06-01T10:00:00Z"),
  "updated_at": ISODate("2025-06-01T10:00:00Z")
}

// Unique environment name per app
{ "app_id": 1, "name": 1 }  // unique: true

// Unique position per app
{ "app_id": 1, "position": 1 }  // unique: true

// Canonical lookup (partial index: only where is_canonical == true)
{ "app_id": 1, "is_canonical": 1 }  // partialFilterExpression: { "is_canonical": true }, unique: true

{
  "_id": ObjectId("664f1a2b3c4d5e6f70809020"),
  "app_id": ObjectId("664f1a2b3c4d5e6f70809010"),
  "name": "Production",
  "position": 3,
  "is_canonical": true,
  "created_at": ISODate("2025-06-01T10:00:00Z"),
  "updated_at": ISODate("2025-06-01T10:00:00Z")
}

{
  "data": [
    {
      "id": "664f1a2b3c4d5e6f70809010",
      "name": "payments-config",
      "repo_path": "conman/payments-config.git",
      "integration_branch": "main",
      "settings": {
        "baseline_mode": "canonical_env_release",
        "canonical_env_id": "664f1a2b3c4d5e6f70809020",
        "commit_mode_default": "submit_commit",
        "blocked_paths": [".git/**", ".gitignore", ".github/**"],
        "file_size_limit_bytes": 5242880
      },
      "created_by": "664f1a2b3c4d5e6f70809001",
      "created_at": "2025-06-01T10:00:00Z",
      "updated_at": "2025-06-01T10:00:00Z"
    }
  ],
  "pagination": { "page": 1, "limit": 20, "total": 1 }
}

{
  "name": "payments-config",
  "repo_path": "conman/payments-config.git"
}

{
  "data": {
    "id": "664f1a2b3c4d5e6f70809010",
    "name": "payments-config",
    "repo_path": "conman/payments-config.git",
    "integration_branch": "main",
    "settings": {
      "baseline_mode": "canonical_env_release",
      "canonical_env_id": null,
      "commit_mode_default": "submit_commit",
      "blocked_paths": [".git/**", ".gitignore", ".github/**"],
      "file_size_limit_bytes": 5242880
    },
    "created_by": "664f1a2b3c4d5e6f70809001",
    "created_at": "2025-06-01T10:00:00Z",
    "updated_at": "2025-06-01T10:00:00Z"
  }
}

{
  "baseline_mode": "integration_head",
  "canonical_env_id": "664f1a2b3c4d5e6f70809020",
  "commit_mode_default": "manual_checkpoint",
  "blocked_paths": [".git/**", ".gitignore", ".github/**", "secrets/**"],
  "file_size_limit_bytes": 10485760
}

{
  "data": [
    {
      "id": "664f1a2b3c4d5e6f70809021",
      "app_id": "664f1a2b3c4d5e6f70809010",
      "name": "Development",
      "position": 0,
      "is_canonical": false,
      "created_at": "2025-06-01T10:00:00Z",
      "updated_at": "2025-06-01T10:00:00Z"
    },
    {
      "id": "664f1a2b3c4d5e6f70809022",
      "app_id": "664f1a2b3c4d5e6f70809010",
      "name": "QA",
      "position": 1,
      "is_canonical": false,
      "created_at": "2025-06-01T10:00:00Z",
      "updated_at": "2025-06-01T10:00:00Z"
    },
    {
      "id": "664f1a2b3c4d5e6f70809023",
      "app_id": "664f1a2b3c4d5e6f70809010",
      "name": "UAT",
      "position": 2,
      "is_canonical": false,
      "created_at": "2025-06-01T10:00:00Z",
      "updated_at": "2025-06-01T10:00:00Z"
    },
    {
      "id": "664f1a2b3c4d5e6f70809020",
      "app_id": "664f1a2b3c4d5e6f70809010",
      "name": "Production",
      "position": 3,
      "is_canonical": true,
      "created_at": "2025-06-01T10:00:00Z",
      "updated_at": "2025-06-01T10:00:00Z"
    }
  ]
}

{
  "environments": [
    { "id": "664f1a2b3c4d5e6f70809021", "name": "Development", "position": 0, "is_canonical": false },
    { "id": "664f1a2b3c4d5e6f70809022", "name": "QA", "position": 1, "is_canonical": false },
    { "id": "new", "name": "Staging", "position": 2, "is_canonical": false },
    { "id": "664f1a2b3c4d5e6f70809020", "name": "Production", "position": 3, "is_canonical": true }
  ]
}

{
  "data": [
    {
      "user_id": "664f1a2b3c4d5e6f70809001",
      "email": "admin@example.com",
      "role": "app_admin",
      "joined_at": "2025-06-01T10:00:00Z"
    },
    {
      "user_id": "664f1a2b3c4d5e6f70809002",
      "email": "dev@example.com",
      "role": "user",
      "joined_at": "2025-06-02T14:30:00Z"
    }
  ],
  "pagination": { "page": 1, "limit": 20, "total": 2 }
}

const DEFAULT_BLOCKED_PATHS: &[&str] = &[
    ".git/**",
    ".gitignore",
    ".github/**",
];

const DEFAULT_FILE_SIZE_LIMIT_BYTES: u64 = 5 * 1024 * 1024; // 5 MB
const MAX_FILE_SIZE_LIMIT_BYTES: u64 = 50 * 1024 * 1024;    // 50 MB upper bound

// shared.proto
message Repository {
  reserved 1;
  reserved "path";
  // storage_name identifies which Gitaly storage the repo lives on.
  string storage_name = 2;
  // relative_path is the path of the repository relative to the storage root.
  string relative_path = 3;
  // git_object_directory sets GIT_OBJECT_DIRECTORY envvar.
  string git_object_directory = 4;
  // git_alternate_object_directories sets GIT_ALTERNATE_OBJECT_DIRECTORIES envvar.
  repeated string git_alternate_object_directories = 5;
  // gl_repository is the identifier used in callbacks to identify the repository.
  string gl_repository = 6;
  reserved 7;
  // gl_project_path is the human-readable project path (e.g. "conman/my-app").
  string gl_project_path = 8;
}

// repository.proto
service RepositoryService {
  rpc RepositoryExists(RepositoryExistsRequest) returns (RepositoryExistsResponse) {
    option (op_type) = { op: ACCESSOR };
  }
  // ...
}

// RepositoryExistsRequest checks whether a given repository exists.
message RepositoryExistsRequest {
  // repository is the repo to check. storage_name and relative_path must be provided.
  Repository repository = 1 [(target_repository)=true];
}

// RepositoryExistsResponse is the response for RepositoryExists.
message RepositoryExistsResponse {
  // exists indicates whether the repo exists.
  bool exists = 1;
}

impl GitalyClient {
    /// Check whether a repository exists on the Gitaly storage.
    pub async fn repository_exists(&self, repo_path: &str) -> Result<bool, ConmanError> {
        let repo = self.build_repository(repo_path);
        let request = RepositoryExistsRequest {
            repository: Some(repo),
        };
        let response = self
            .repository_service()
            .repository_exists(request)
            .await
            .map_err(|e| ConmanError::Git {
                message: format!("RepositoryExists failed: {e}"),
            })?;
        Ok(response.into_inner().exists)
    }
}

// repository.proto
service RepositoryService {
  rpc CreateRepository(CreateRepositoryRequest) returns (CreateRepositoryResponse) {
    option (op_type) = { op: MUTATOR };
  }
  // ...
}

// CreateRepositoryRequest creates a new repository on the Gitaly storage.
message CreateRepositoryRequest {
  // repository to create. storage_name and relative_path must be provided.
  Repository repository = 1 [(target_repository)=true];
  // default_branch is the branch name to set as default (not a fully qualified ref).
  bytes default_branch = 2;
  // object_format is the object format the repo should use. Experimental.
  ObjectFormat object_format = 3;
}

// CreateRepositoryResponse is the response for CreateRepository.
// An empty response denotes success.
message CreateRepositoryResponse {
}

impl GitalyClient {
    /// Create a new bare repository on the Gitaly storage.
    pub async fn create_repository(
        &self,
        repo_path: &str,
        default_branch: &str,
    ) -> Result<(), ConmanError> {
        let repo = self.build_repository(repo_path);
        let request = CreateRepositoryRequest {
            repository: Some(repo),
            default_branch: default_branch.as_bytes().to_vec(),
            object_format: 0, // OBJECT_FORMAT_UNSPECIFIED, defaults to SHA1
        };
        self.repository_service()
            .create_repository(request)
            .await
            .map_err(|e| ConmanError::Git {
                message: format!("CreateRepository failed: {e}"),
            })?;
        Ok(())
    }
}

impl GitalyClient {
    /// Build a gitaly Repository message from a Conman repo_path.
    fn build_repository(&self, repo_path: &str) -> Repository {
        Repository {
            storage_name: "default".to_string(),
            relative_path: repo_path.to_string(),
            gl_repository: String::new(),
            gl_project_path: String::new(),
            git_object_directory: String::new(),
            git_alternate_object_directories: vec![],
        }
    }
}