from index_page import makeIndexHtml
from output import affinityToNode, build, createIngress, createPv, createPvc, toJson, createSvc


def createAgentDeploy(tzArg, vmVersion, pipelineWebRoot, agentFileName, agentName, agentPort, scrapeMapKey, insertName, pipelineName):
    (build / f'{agentFileName}_deploy.yaml').write_text(
        toJson({
            "apiVersion": "apps/v1", "kind": "Deployment", "metadata": { "name": agentName },
            "spec": {
                "replicas": 1, "strategy": { "type": "Recreate" }, "selector": { "matchLabels": { "app": agentName } },
                "template": {
                    "metadata": {
                        "labels": { "app": agentName },
                        "annotations": { "prometheus.io/scrape": "true", "prometheus.io/path": f"{pipelineWebRoot}/vmagent/metrics", "prometheus.io/port": "80" }
                    },
                    "spec": {
                        "volumes": [{ "name": "config", "configMap": { "name": "victoriametrics-config" } }],
                        "serviceAccountName": "victoriametrics",
                        "containers": [{
                            "name": "vmagent",
                            "image": f"docker.io/victoriametrics/vmagent:{vmVersion}",
                            "imagePullPolicy": "IfNotPresent",
                            "args": [
                                f"-http.pathPrefix={pipelineWebRoot}/vmagent/",
                                tzArg,
                                f"-promscrape.config=/local/config/{scrapeMapKey}",
                                "-promscrape.configCheckInterval=5s",
                                "-sortLabels",
                                f"-remoteWrite.url=http://{insertName}{pipelineWebRoot}/vminsert/insert/0/prometheus/api/v1/write",
                                "-remoteWrite.showURL",
                            ],
                            "ports": [{ "containerPort": agentPort }],
                            "volumeMounts": [{ "name": "config", "mountPath": "/local/config" }]
                        }]
                    }
                }
            }
        })) # yapf: disable


def createInsertDeploy(tzArg, vmVersion, pipelineWebRoot, insertName, storageName, insertFileName, insertPort):
    (build / f'{insertFileName}_deploy.yaml').write_text(
        toJson({
            "apiVersion": "apps/v1", "kind": "Deployment", "metadata": { "name": insertName },
            "spec": {
                "replicas": 1, "strategy": { "type": "Recreate" }, "selector": { "matchLabels": { "app": insertName } },
                "template": {
                    "metadata": {
                        "labels": { "app": insertName },
                        "annotations": { "prometheus.io/scrape": "true", "prometheus.io/path": "/m/metrics", "prometheus.io/port": "80" }
                    },
                    "spec": {
                        "serviceAccountName": "victoriametrics",
                        "containers": [{
                            "name": "vminsert",
                            "image": f"docker.io/victoriametrics/vminsert:{vmVersion}-cluster",
                            "imagePullPolicy": "IfNotPresent",
                            "args": [
                                f"-http.pathPrefix={pipelineWebRoot}/vminsert/",
                                tzArg,
                                f"-storageNode={storageName}",
                            ],
                            "ports": [{ "containerPort": insertPort }]
                        }]
                    }
                }
            }
        })) # yapf: disable


def createStorageDeploy(tzArg, vmVersion, pipelineWebRoot, pipelineName, retention, storageName, storageFileName, localPvHost, volName, storageInsertPort, storageSelectPort):
    (build / f'{storageFileName}_2deploy.yaml').write_text(
        toJson({
            "apiVersion": "apps/v1", "kind": "Deployment", "metadata": { "name": storageName },
            "spec": {
                "replicas": 1, "strategy": { "type": "Recreate" }, "selector": { "matchLabels": { "app": storageName } },
                "template": {
                    "metadata": {
                        "labels": { "app": storageName },
                        "annotations": { "prometheus.io/scrape": "true", "prometheus.io/path": "/m/vmstorage/metrics", "prometheus.io/port": "80" }
                    },
                    "spec": {
                        "volumes": [{ "name": "data", "persistentVolumeClaim": { "claimName": volName } }],
                        "serviceAccountName": "victoriametrics",
                        "containers": [{
                            "name": "vmstorage",
                            "image": f"docker.io/victoriametrics/vmstorage:{vmVersion}-cluster",
                            "imagePullPolicy": "IfNotPresent",
                            "args": [
                                f"-http.pathPrefix={pipelineWebRoot}/vmstorage/",
                                tzArg,
                                f"-retentionPeriod={retention}",
                                f"-storageDataPath=/data/{pipelineName}",
                            ],
                            "ports": [
                                { "containerPort": 8482, "name": "http" },
                                { "containerPort": storageInsertPort, "name": "vminsert" },
                                { "containerPort": storageSelectPort, "name": "vmselect" },
                            ],
                            "volumeMounts": [{ "name": "data", "mountPath": "/data" }]
                        }],
                        "affinity": affinityToNode(localPvHost)
                    }
                }
            }
        })) # yapf: disable


def createVmselectDeploy(tzArg, vmVersion, webRoot, objPrefix, storageSvcs, selectPort):
    name = f"{objPrefix}-vmselect"
    (build / f'{objPrefix}-1vmselect_deploy.yaml').write_text(
        toJson({
            "apiVersion": "apps/v1", "kind": "Deployment", "metadata": { "name": name },
            "spec": {
                "replicas": 1,
                "strategy": { "type": "Recreate" },
                "selector": { "matchLabels": { "app": name } },
                "template": {
                    "metadata": {
                        "labels": { "app": name },
                        "annotations": { "prometheus.io/scrape": "true", "prometheus.io/path": "/m/metrics", "prometheus.io/port": "80" }
                    },
                    "spec": {
                        "serviceAccountName": "victoriametrics",
                        "containers": [{
                            "name": "vmselect", "image": f"docker.io/victoriametrics/vmselect:{vmVersion}-cluster", "imagePullPolicy": "IfNotPresent",
                            "args": [
                                f"-http.pathPrefix={webRoot}/vmselect/",
                                tzArg,
                            ] + [f"-storageNode={n}" for n in storageSvcs],
                            "ports": [{ "containerPort": selectPort }]
                        }]
                    }
                }
            }
        })) # yapf: disable

def createIngestPipeline(tzArg, vmVersion, webRoot, objPrefix, pipelineName, scrapeMapKey, retention):
    agentName = f"{objPrefix}-{pipelineName}-vmagent"
    insertName = f"{objPrefix}-{pipelineName}-vminsert"
    storageName = f"{objPrefix}-{pipelineName}-vmstorage"

    agentFileName = f"{objPrefix}-0{pipelineName}-0vmagent"
    insertFileName = f"{objPrefix}-0{pipelineName}-1vminsert"
    storageFileName = f"{objPrefix}-0{pipelineName}-2vmstorage"

    localPvHost = "ditto"
    insertPort = 8480
    agentPort = 8429
    storageInsertPort = 8400
    storageSelectPort = 8401
    volName = f"{objPrefix}-data-{pipelineName}"
    request = "50Gi"
    pipelineWebRoot = f'{webRoot}/{pipelineName}'

    createAgentDeploy(tzArg, vmVersion, pipelineWebRoot, agentFileName, agentName, agentPort, scrapeMapKey, insertName, pipelineName)
    createInsertDeploy(tzArg, vmVersion, pipelineWebRoot, insertName, storageName, insertFileName, insertPort)
    createPv(storageFileName, volName, request)
    createPvc(storageFileName, volName, request)
    createStorageDeploy(tzArg, vmVersion, pipelineWebRoot, pipelineName, retention, storageName, storageFileName, localPvHost, volName, storageInsertPort, storageSelectPort)

    createSvc(agentFileName, agentName, [{"port": 80, "targetPort": agentPort}])
    createSvc(insertFileName, insertName, [{"port": 80, "targetPort": insertPort}])
    createSvc(storageFileName,storageName, [
        {"port": 80, "targetPort": "http", "name": "http"},
        {"port": storageInsertPort, "targetPort": "vminsert", "name": "vminsert"},
        {"port": storageSelectPort, "targetPort": "vmselect", "name": "vmselect"},
        ]) # yapf: disable

    return storageName


def createIndex(objPrefix, webRoot, html):
    name = f'{objPrefix}-index'
    httpServeRoot = '/opt/html'

    (build / f'{objPrefix}-3index_cmap.yaml').write_text(toJson({
        "apiVersion": "v1", "kind": "ConfigMap", "metadata": { "name": name },
        "data": {
            "index.html": html,
(??)        }
(??)    }))
(??)(build / 'vmselect_svc.yaml').write_text(toJson({
(??)    "apiVersion": "v1",
(??)    "kind": "Service",
(??)    "metadata": {
(??)        "name": "next-victoriametrics-vmselect"
(??)    },
(??)    "spec": {
(??)        "ports": [{
(??)            "port": 80,
(??)            "targetPort": 8481
(??)        }],
(??)        "selector": {
(??)            "app": "next-victoriametrics-vmselect"
(??)        }
(??)    }
(??)}
(??)                                                # in vmui, set server url to
(??)                                                # https://bigasterisk.com/m/next/vmselect/select/0/prometheus
(??)                                               ))
(??)
(??)(build / 'vmselect_svc.yaml').write_text(
(??)    toJson({
(??)        "apiVersion": "networking.k8s.io/v1",
(??)        "kind": "Ingress",
(??)        "metadata": {
(??)            "name": "next-victoriametrics",
(??)            "annotations": {
(??)                "cert-manager.io/cluster-issuer": "letsencrypt-prod",
(??)                "ingress.pomerium.io/allow_public_unauthenticated_access": "false",
(??)                "ingress.pomerium.io/pass_identity_headers": "true",
(??)                "ingress.pomerium.io/preserve_host_header": "true",
    })) # yapf: disable
    
    (build / f'{objPrefix}-3index_deploy.yaml').write_text(
        toJson({
            "apiVersion": "apps/v1", "kind": "Deployment", "metadata": { "name": name },
            "spec": {
                "replicas": 1,
                "selector": { "matchLabels": { "app": name } },
                "template": {
                    "metadata": { "labels": { "app": name } },
                    "spec": {
                        "containers": [{
                            "name": "webserver", "image": "docker.io/joseluisq/static-web-server", "imagePullPolicy": "IfNotPresent",
                            "args": [
                                f'--root={httpServeRoot}',
                                '--directory-listing=true',
                                '--experimental-metrics=true',
                            ],
                            "ports": [{ "containerPort": 80 }],
                            "volumeMounts": [{ "name": "html", "mountPath": f"{httpServeRoot}{webRoot}" }]
                        }],
                        "volumes": [{ "name": "html", "configMap": { "name": name, "defaultMode": 444 } }]
                    }
                }
            }
        })) # yapf: disable
    createSvc(f'{objPrefix}-3index', f'{objPrefix}-index', [{'port': 80, 'targetPort': 80}])

(build / 'vmselect_svc.yaml').write_text(
    toJson({
        "apiVersion": "networking.k8s.io/v1",
        "kind": "Ingress",
        "metadata": {
            "name": "next-victoriametrics",
            "annotations": {
                "cert-manager.io/cluster-issuer": "letsencrypt-prod",
                "ingress.pomerium.io/allow_public_unauthenticated_access": "false",
                "ingress.pomerium.io/pass_identity_headers": "true",
                "ingress.pomerium.io/preserve_host_header": "true",
            }
        },
        "spec": {
            "ingressClassName": "pomerium",
            "rules": [{
                "host": "bigasterisk.com",
                "http": {
                    "paths": [{
                        "pathType": "Prefix",
                        "path": "/m/next/vmselect/",
                        "backend": {
                            "service": {
                                "name": "next-victoriametrics-vmselect",
                                "port": {
                                    "number": 80
                                }
                            }
                        }
                    }, {
                        "pathType": "Prefix",
                        "path": "/m/next/vmagent/",
                        "backend": {
                            "service": {
                                "name": "next-victoriametrics-vmagent",
                                "port": {
                                    "number": 80
                                }
                            }
                        }
                    }, {
                        "pathType": "Prefix",
                        "path": "/m/next/vmselect/",
                        "backend": {
                            "service": {
                                "name": "next-victoriametrics-vmselect",
                                "port": {
                                    "number": 80
                                }
                            }
                        }
                    }]
                }
            }],
            "tls": [{
                "hosts": ["bigasterisk.com"],
                "secretName": "bigasterisk.com-tls"
            }]
        }
    }))