---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myApp
spec:
  replicas: 1
  template:
    spec:
      containers:
        - image: myApp/myImage:v0.0.1
          name: myApp
          ports:
            - name: http
              containerPort: 8080

---
apiVersion: karbon/v1alpha1
kind: Karbonfile
resources:
  - ../../base
transformations:
  - target:
      kind: Deployment
    patches:
      - op: add
        path: /spec/template/spec/containers/0/command
        value: ["web"]
      - op: add
        path: /spec/template/spec/containers/0/args
        value:  ["start", "-p", "8080"]

---
apiVersion: karbon/v1alpha1
kind: Karbonfile
resources:
  - ../../base
transformations:
  - target:
      kind: Deployment
    patches:
      - op: add
        path: /spec/template/spec/containers/0/command
        value: ["worker"]

---

  - deployment.yml
  - service.yml

  ? !karbonfile ../../base

  - labels:
      app.kubernetes.io/name: flower
      app.kubernetes.io/component: flower

  - nameSuffix: '-worker'

  name: myApp

  name: test

      port: 80
      targetPort: 8080

      port: 8080
      targetPort: http

apiVersion: karbon/v1alpha1
kind: Karbonfile
resources:
 ? !karbonfile ../../base
 ? !files service.yml
 ? !files ingress.yml
transformations:
  - nameSuffix: '-web'
  - filter:
      kind: Deployment
      metadata:
        name: test
    add:
      /spec/template/spec/containers/0/ports/-/containerPort: 8080
      .spec.revisionHistoryLimit: 3
      spec:
        strategy:
          rollingUpdate:
            maxUnavailable: 0
            maxSurge: 50%

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  creationTimestamp: null
  name: test
spec:
  rules:
  - host: test.local
    http:
      paths:
      - backend:
          service:
            name: test
            port:
              number: 8080
        path: /
        pathType: Exact
status:
  loadBalancer: {}

---

  - ../../overlays/worker
  - ../../overlays/web

  ? !karbonfile ../../overlays/worker
  ? !karbonfile ../../overlays/web

  - target:
      kind: Deployment
    replicas: 5

apiVersion: karbon/v1alpha1
kind: Karbonfile
resources:
  ? !files deployment.yml
transformations: []

apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: test
  name: test
spec:
  replicas: 1
  selector:
    matchLabels:
      app: test
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: test
    spec:
      containers:
      - image: bash
        name: bash
        resources: {}
status: {}

use std::collections::HashMap;

use std::collections::{HashMap};
use std::hash::{Hash, Hasher};

#[derive(Deserialize, Debug)]

#[derive(Deserialize, Clone, Debug)]

#[serde(deny_unknown_fields)]

    resources: Vec<PathBuf>,

    resources: HashMap<Resource, ()>,

#[derive(Deserialize, Debug)]

#[derive(Deserialize, Clone, Debug)]
#[serde(rename_all = "lowercase")]
#[serde(deny_unknown_fields)]
enum Resource {
    Files(PathBuf),
    Karbonfile(PathBuf),
    //Git { path: PathBuf },
}
impl Resource {
    fn path(&self) -> PathBuf {
        use Resource::*;
        match self {
            Files(p) => { p.clone() }
            Karbonfile(p) => { p.clone() }
        }
    }
}
impl PartialEq for Resource {
    fn eq(&self, other: &Self) -> bool {
        self.path() == other.path()
    }
}
impl Eq for Resource {}
impl Hash for Resource {
    fn hash<H: Hasher>(&self, state: &mut H) {
        use Resource::*;
        match self {
            Files(p) => p.hash(state),
            Karbonfile(p) => p.hash(state),
        }
    }
}
#[derive(Deserialize, Clone, Debug)]

#[derive(Deserialize, Debug)]

#[derive(Deserialize, Clone, Debug)]

#[serde(rename_all = "camelCase")]

    #[serde(default)]
    target: Target,
    #[serde(default)]
    namespace: String,

    patches: Vec<JSONPatch>,

    filter: Option<serde_yaml::Value>,

    replicas: u8,

    namespace: Option<String>,

    labels: HashMap<String, String>,
}
#[derive(Deserialize, Default, Debug)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "camelCase")]
struct Target {

    replicas: Option<u8>,

    api_group: String,

    labels: Option<HashMap<String, String>>,

    api_version: String,

    add: Option<serde_yaml::Mapping>,

    kind: String,

    replace: Option<serde_yaml::Mapping>,

    name: String,

    remove: Option<serde_yaml::Mapping>,

    namespace: String,

    name_prefix: Option<String>,

    labels: HashMap<String, String>,

    name_suffix: Option<String>,

#[derive(Deserialize, Debug)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "camelCase")]
struct JSONPatch {
    op: JSONPatchOp,
    path: String,
    value: serde_yaml::Value,
}
#[derive(Deserialize, Debug)]
#[serde(rename_all = "lowercase")]
enum JSONPatchOp {
    Add,
    Replace,
}

#[derive(Deserialize, Debug)]

#[derive(Deserialize, Clone, Debug)]

        // First is a diretory and second is relative.

        // First is a directory and second is relative.

}
#[derive(Clone, Debug)]
struct TransformationSet {
    resource_path: Option<PathBuf>,
    transformations: HashMap<PathBuf, Vec<Transformation>>,

impl TransformationSet {
    fn new() -> TransformationSet {
        TransformationSet {
            resource_path: None,
            transformations: HashMap::new(),
        }
    }

fn build_tree(path: PathBuf, mut branch: Vec<PathBuf>, result: &mut Vec<Vec<PathBuf>>) {
    let canonical = find_resource_file(&path);

    fn set_path(&mut self, p: PathBuf) {
        self.resource_path = Some(p);
    }
    fn add_transformation(&mut self, p: PathBuf, t: Vec<Transformation>) {
        self.transformations.insert(p, t);
    }
}

    // add the current path to the branch we are building
    branch.push(canonical.clone());

fn build_tree(path: PathBuf, mut tset: TransformationSet, result: &mut Vec<TransformationSet>) {
    let canonical = find_resource_file(&path);

        let resources: Vec<PathBuf> = parse_karbonfile(&canonical)

        let karbonfile = parse_karbonfile(&canonical);
        let resources: Vec<Resource> = karbonfile

            .into_iter()

            .iter()
            .map(|(k, v)| k.clone())

        tset.add_transformation(canonical.clone(), karbonfile.transformations);

            result.push(branch);

            tset.set_path(canonical.clone());

                let next_path = merge_relative_path(&path, &r);

                let next_path = merge_relative_path(&path, &r.path());

                build_tree(next_path, branch.clone(), result);

                build_tree(next_path, tset.clone(), result);

        // leaf since it's not a karbonfile
        result.push(branch);

        // Leaf since it's not a karbonfile.
        // Add the path to the resource_path.
        tset.set_path(canonical.clone());

    result.push(tset);

            let mut result: Vec<Vec<PathBuf>> = Vec::new();

            let mut result: Vec<TransformationSet> = Vec::new();
            build_tree(path, TransformationSet::new(), &mut result);

            build_tree(path, Vec::new(), &mut result);
            for i in result.iter() {
                println!("{:?}", i);
            }

            println!("{:#?}", &result);