#!groovy

import com.freeleaps.devops.SourceFetcher
import com.freeleaps.devops.DependenciesResolver
import com.freeleaps.devops.enums.DependenciesManager
import com.freeleaps.devops.enums.ServiceLanguage
import com.freeleaps.devops.CommitMessageLinter
import com.freeleaps.devops.ChangedComponentsDetector

def call(configurations) {

  def sourceFetcher = new SourceFetcher(this)

  pipeline {
    agent any
    options {
      buildDiscarder(logRotator(numToKeepStr: '25'))
      timeout(time: 30, unit: 'MINUTES')
    }

    stages {
      stage("Commit Linting If Enabled") {
        agent {
          kubernetes {
            defaultContainer 'commit-message-linter'
            yaml """
apiVersion: v1
kind: Pod
metadata:
  labels:
    freeleaps-devops-system/milestone: commit-message-linting
spec:
  containers:
  - name: commit-message-linter
    image: docker.io/commitlint/commitlint:master
    command:
    - cat
    tty: true
    volumeMounts:
    - name: workspace
      mountPath: /workspace
  volumes:
    - name: workspace
      emptyDir: {} 
"""
          }
        }
        steps {
          script {
            def enabled = configurations.commitMessageLintEnabled
            
            if (enabled == null || !enabled) {
              log.warn "Commit message linting is disabled"
            } else if (enabled) {
              log.info "Commit message linting is enabled"
              sourceFetcher.fetch(configurations)

              def linter = new CommitMessageLinter(this)
              linter.lint(configurations)
            }
          }
        }
      }

      stage("Execute Mode Detection") {
        steps {
          script {
            def executeMode = configurations.executeMode
            if (executeMode == null || executeMode.isEmpty()) {
              log.warn "Not set executeMode, using fully as default execute mode"
              env.executeMode = "fully"
            } else if (executeMode == 'on-demand' && serviceGitRepoType != 'monorepo') {
              log.warn "serviceGirRepoType is not monorepo, on-demand mode is not supported, using fully mode"
              env.executeMode = "fully"
            } else {
              log.info "Using ${executeMode} as execute mode"
              env.executeMode = executeMode
            }
          }
        }
      }

      stage("Code Changes Detection") {
        steps {
          when {
            expression {
              return env.executeMode == "on-demand"
            }
          }

          script {
            sourceFetcher.fetch(configurations)

            def changedComponentsDetector = new ChangedComponentsDetector(this)
            def changedComponents = changedComponentsDetector.detect(env.workspace, configurations.components)

            log.info "Changed components: ${changedComponents}"
            env.changedComponents = changedComponents.join(' ')
          }
        }
      }

      stage("Components Build (Dynamic Generated Stages)") {
        steps {
          script {
            configurations.components.each { component ->
              stage("${component} :: Build Agent Setup") {
                when {
                  expression {
                    return env.executeMode == "fully" || env.changedComponents.contains(component)
                  }
                }

                steps {
                  script {
                    def buildAgentImage = component.buildAgentImage
                    if (buildAgentImage == null || buildAgentImage.isEmpty()) {
                      log.warn "Not set buildAgentImage for ${component}, using default build agent image"

                      def language = ServiceLanguage.parse(configurations.serviceLang)
                      switch(language) {
                        case ServiceLanguage.PYTHON:
                          buildAgentImage = "python:3.10-slim-buster"
                          break
                        case ServiceLanguage.JS:
                          buildAgentImage = "node:lts-alpine"
                          break
                        default:
                          error("Unknown service language")
                      }

                      log.info "Using ${buildAgentImage} as build agent image for ${component}"
                      env.buildAgentImage = buildAgentImage
                    }
                  }
                }
              }

              stage("${component} :: Dependencies Resolving") {
                when {
                  expression {
                    return env.executeMode == "fully" || env.changedComponents.contains(component)
                  }
                }

                agent {
                  kubernetes {
                    defaultContainer 'dep-resolver'
                    yaml """
      apiVersion: v1
      kind: Pod
      metadata:
        labels:
          freeleaps-devops-system/milestone: dependencies-resolving
      spec:
        containers:
        - name: dep-resolver
          image: ${env.buildAgentImage}
          command:
          - cat
          tty: true
          volumeMounts:
          - name: workspace
            mountPath: /workspace
        volumes:
          - name: workspace
            emptyDir: {}
      """
                  }
                }

                steps {
                  script {
                    def language = ServiceLanguage.parse(component.language)

                    def depManager = DependenciesManager.parse(component.dependenciesManager)

                    def dependenciesResolver = new DependenciesResolver(this, language)
                    dependenciesResolver.useManager(depManager)
                    
                    if (component.buildCacheEnabled) {
                      dependenciesResolver.enableCachingSupport()
                    } else {
                      dependenciesResolver.disableCachingSupport()
                    }

                    sourceFetcher.fetch(configurations)
                    dependenciesResolver.resolve(configurations)
                  }
                }
              }
            }
          }
        }
      }

    }
  }
}