(json-encode
 (-map (lambda (siterow)
         (pcase-let* ((`(,title ,key ,css ,link) siterow))
           `((title . ,title)
             (key . ,key)
             (css_file . ,(format "arcology/css/%s" css))
             (link_color . ,link)
             (domains . ,(-map #'cadr
                            (-filter (pcase-lambda (`(,dkey ,domain))
                                       (equal key dkey))
                                     domains))))))
       sites))

<<elisp-join-tables()>>

(thread-last domains
             (-map (pcase-lambda (`(,site ,domain))
                     domain))
             (s-join ","))

(pcase-let ((`((,name ,alert ,primary ,secondary ,success ,warning ,white ,gray2 ,gray3 , gray4 ,black))
             (-filter (lambda (row)
                        (equal (first row) site))
                      colors)))
  (s-join "\n"
          (list ":root {"
                (concat "  --alert: " alert ";")
                (concat "  --primary: " primary ";")
                (concat "  --secondary: " secondary ";")
                (concat "  --success: " success ";")
                (concat "  --warning: " warning ";")
                (concat "  --white: " white ";")
                (concat "  --light-gray: " gray2 ";")
                (concat "  --medium-gray: " gray3 ";")
                (concat "  --dark-gray: " gray4 ";")
                (concat "  --black: " black ";")
                "}")))

<<mk-site-colors(site-colors, "default-colors")>>

<<mk-site-colors(site-colors, "cce")>>

<<mk-site-colors(site-colors, "lionsrear")>>

<<mk-site-colors(site-colors, "garden")>>

<<mk-site-colors(site-colors, "arcology")>>

{ inputs, systems, pkgs, ... }:

let
  arcology = inputs.arcology.packages.${pkgs.stdenv.hostPlatform.system}.default;
in {
  imports = [ ./arcology2-module.nix ];

  fileSystems."/media/org" = {
    device = "/home/rrix/org";
    options = ["bind"];
    fsType = "none";
    depends = ["/home" "/media"];
  };

  services.arcology-ng = {
    enable = true;
    packages.arcology = arcology;
    domains = pkgs.lib.splitString "," "<<get_allowed_hosts()>>";
    orgDir = "/media/org";
    folderId = "p1kld-oxnwd";
    dataDir = "/srv/arcology";
    logLevel = "INFO";
    ollamaHost = "windows:11434";
  };
}

arcology = {
  url = "path:/home/rrix/org/arcology-django";
  inputs.nixpkgs.follows = "nixpkgs";
};

{ osConfig, inputs, system, pkgs, ... }: 

let
  hostname = osConfig.networking.hostName or "default";
  arcology = inputs.arcology.packages.${system}.default; 
in {
  imports = [ ./arcology-localapi-mod.nix ];

  services.arcology2 = {
    enable = true;
    packages.arcology = arcology;
    folderId = pkgs.lib.mkDefault "p1kld-oxnwd";
    logLevel = "INFO";
    environmentFile = "/home/rrix/sync/private-files/.arcology-env-${hostname}";
    ollamaHost = "windows:11434";

    address = "0.0.0.0";
  };
}

from pathlib import Path
import os

from .generators import *

# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent.parent
DATABASE_PATH = pathlib.Path(os.getenv("ARCOLOGY_DB_PATH", pathlib.Path(os.getcwd()) / "db.sqlite3")).expanduser()
WRITABLE_DB_PATH = pathlib.Path(os.getenv("ARCOLOGY_DB_WRITE_PATH", pathlib.Path(os.getcwd()) / "writable.sqlite3")).expanduser()

SECRET_KEY = os.getenv("ARCOLOGY_DJANGO_SECRET", "devsecret")

ARCOLOGY_ENVIRONMENT = os.getenv("ARCOLOGY_ENVIRONMENT", "dev")
DEBUG = (ARCOLOGY_ENVIRONMENT != "production")

SYNCTHING_KEY = os.getenv("ARCOLOGY_SYNCTHING_KEY")

BASE_CACHE_PATH = pathlib.Path(os.environ.get("ARCOLOGY_CACHE_PATH", '~/.cache/arcology2')).expanduser()
CACHES = {
    'default': {
        'BACKEND': 'django_prometheus.cache.backends.filebased.FileBasedCache',
        'LOCATION': BASE_CACHE_PATH,
    },
}

LOCALAPI_BEARER_TOKEN = os.environ.get("ARCOLOGY_LOCALAPI_BEARER_TOKEN", "changeme!")

MEDIA_ROOT = BASE_CACHE_PATH.joinpath("media")
MEDIA_URL = "media/"
ATTACHMENT_DIR = BASE_CACHE_PATH.joinpath("attachments")

ALLOWED_HOSTS = "<<get_allowed_hosts()>>".split(',')

# Application definition
INSTALLED_APPS = [
    <<gen-config-list(arcology_apps)>>
    "django_htmx",
    "django_prometheus",
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
]
if ARCOLOGY_ENVIRONMENT != "production":
  INSTALLED_APPS = ["localapi"] + INSTALLED_APPS

# Internationalization
# https://docs.djangoproject.com/en/3.2/topics/i18n/

LANGUAGE_CODE = "en-us"
TIME_ZONE = "America/Los_Angeles"
USE_I18N = True
USE_L10N = True
USE_TZ = True

LOGGING = {
    "version": 1,
    "disable_existing_loggers": False,
    "handlers": {
        "console": {
            "class": "logging.StreamHandler",
        },
    },
    "loggers": {
        "django": {
            "handlers": ["console"],
            "level": os.getenv("DJANGO_LOG_LEVEL", "INFO"),
            "propagate": False,
        },
        "arcology.cache_decorator": { # left as an example to change later.
            "handlers": ["console"],
            "level": "DEBUG",
        }
    },
    "root": {
        "handlers": ["console"],
        "level": os.getenv("ARCOLOGY_LOG_LEVEL", "INFO"),
    },
}

import pathlib
import os

ARCOLOGY_BASE_DIR = pathlib.Path(os.environ.get("ARCOLOGY_BASE_DIR", "~/org")).expanduser()
ARCOLOGY_EMACS_SNIPPETS_DIR = str(pathlib.Path("~/org/cce/").expanduser())
ARROYO_BASE_DIR = str(pathlib.Path("~/arroyo-nix").expanduser())

ARCOLOGY_EXTRACTORS = [
  <<gen-config-list(arcology_extractors)>>
]

ARROYO_EXTRACTORS = {
  <<gen-config-dict(arroyo_extractors)>>
}

ARROYO_ROLES = [
  <<gen-config-list(arroyo-roles)>>
]

ROAM_ALLOWED_KEYWORDS = [
  <<gen-config-list(roam_allowed_keywords)>>
  <<gen-config-list(my_roam_allowed_keywords)>>
# used for deprecated universal-aggregator feed generation
    "ARROYO_FEEDS",
    "ARROYO_FEED_CATEGORY",
    "ARROYO_FEED_URL",
# unused
    "CCE_HOME_MODULE",
    "ARROYO_EMACS_TANGLED",
    "ARROYO_MODULE_DEP",
]

IGNORED_ROAM_TAGS = [
  <<gen-config-list(ignored_roam_tags)>>
]

MIDDLEWARE = [
    "django_prometheus.middleware.PrometheusBeforeMiddleware",
    "django_htmx.middleware.HtmxMiddleware",
    "django.middleware.security.SecurityMiddleware",
    "django.contrib.sessions.middleware.SessionMiddleware",
    "django.middleware.common.CommonMiddleware",
    "django.middleware.csrf.CsrfViewMiddleware",
    "django.contrib.auth.middleware.AuthenticationMiddleware",
    "django.contrib.messages.middleware.MessageMiddleware",
    "django.middleware.clickjacking.XFrameOptionsMiddleware",
    "django_prometheus.middleware.PrometheusAfterMiddleware",
]

ROOT_URLCONF = "arcology.urls"

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [],
        "APP_DIRS": True,
        "OPTIONS": {
            "context_processors": [
                "django.template.context_processors.debug",
                "django.template.context_processors.request",
                "django.contrib.auth.context_processors.auth",
                "django.contrib.messages.context_processors.messages",
            ],
        },
    },
]

WSGI_APPLICATION = "arcology.wsgi.application"
ASGI_APPLICATION = "arcology.asgi.application"

CHANNEL_LAYERS = {
    "default": {
        "BACKEND": "channels_redis.core.RedisChannelLayer",
        "CONFIG": {
            "hosts": [("127.0.0.1", 6379)],
            "group_expiry": 3600,
        },
    },
}

# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases

DATABASES = {
    "default": {
        "ENGINE": "django_prometheus.db.backends.sqlite3",
        "NAME": DATABASE_PATH,
    },
    "writable": {
        # "ENGINE": "django_sqlite_vec.conn",
        "ENGINE": "django_prometheus.db.backends.sqlite3",
        "NAME": WRITABLE_DB_PATH,
    }
}

# important to separate things which come from docs from the web so that the docs can be safely re-parsed
# XXX make this configurable
class WriteRouter:
    route_app_labels = {"reservations"}
    route_model_names = {"reservations_pendingregistration", "pendingreservation",
                         }

    def db_for_read(self, model, **hints):
        if model._meta.app_label in self.route_app_labels:
            return "writable"
        return None

    def db_for_write(self, model, **hints):
        if model._meta.app_label in self.route_app_labels:
            return "writable"
        return None

    def allow_relation(self, obj1, obj2, **hints):
        if (
            obj1._meta.app_label in self.route_app_labels
            or obj2._meta.app_label in self.route_app_labels
        ):
            return True
        return None

    def allow_migrate(self, db, app_label, model_name=None, **hints):
        if app_label in self.route_app_labels:
            return db == "writable"
        return None

DATABASE_ROUTERS = [ "arcology.settings.WriteRouter" ]

# Password validation
# https://docs.djangoproject.com/en/3.2/ref/settings/#auth-password-validators

AUTH_PASSWORD_VALIDATORS = [
    {
        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
    },
    {
        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
    },
    {
        "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
    },
    {
        "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
    },
]

# to ensure that nginx frontend proxy_pass is still considered secure
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')

CSRF_TRUSTED_ORIGINS = list(map(lambda it: f"https://{it}", "<<get_allowed_hosts()>>".split(',')))

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.2/howto/static-files/

STATIC_URL = "/static/"

STORAGES = {
    "default": {
        "BACKEND": "django.core.files.storage.FileSystemStorage",
    },
    "staticfiles": {
        "BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage",
    },
}
STATICFILES_DIRS = [
    BASE_DIR / "arcology/static",
    BASE_DIR / "sitemap/static",
]

STATIC_ROOT = os.getenv("ARCOLOGY_STATIC_ROOT", "/var/www/arcology")

# Default primary key field type
# https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field

DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"

(mapconcat (lambda (row)
             (format "\"%s\", # %s\n" (first row) (second row)))
           tbl)

(mapconcat (lambda (row)
             (format "\"%s\": \"%s\",\n" (first row) (second row)))
           tbl)