# PUBLIC DOMAIN - NO LICENSE, NO WARRANTY
# Copyright 2025 TimeHexOn & foxhop & russell@unturf
# https://www.permacomputer.com

# Makefile for ai.unturf.com Language Examples
# This Makefile contains commands for building and testing language example implementations
# Each language demonstrates usage of Hermes AI, Qwen Coder, and TTS endpoints

# Docker image prefix
IMAGE_PREFIX := ai-unturf

# Languages directory (now in public/)
LANGUAGES_DIR := public/languages

# Test endpoints
MODEL_ENDPOINT_1 := https://hermes.ai.unturf.com/v1
MODEL_ENDPOINT_2 := https://qwen.ai.unturf.com/v1
TTS_ENDPOINT_1 := https://speech.ai.unturf.com/v1

# Docker run environment variables
DOCKER_ENV := -e MODEL_ENDPOINT_1=$(MODEL_ENDPOINT_1) -e MODEL_ENDPOINT_2=$(MODEL_ENDPOINT_2) -e TTS_ENDPOINT_1=$(TTS_ENDPOINT_1)

.PHONY: help
help:
	@echo "Language Examples Makefile Commands:"
	@echo ""
	@echo "  make languages-list              - List all language directories"
	@echo "  make languages-build-python      - Build Docker image for Python"
	@echo "  make languages-test-python       - Test Python implementation"
	@echo "  make languages-run-python        - Run Python container interactively"
	@echo "  make languages-stop-python       - Stop Python container"
	@echo "  make languages-clean-python      - Remove Python container and image"
	@echo ""
	@echo "  make languages-build-all         - Build all language Docker images"
	@echo "  make languages-test-all          - Test all language implementations"
	@echo "  make languages-stop-all          - Stop all language containers"
	@echo "  make languages-clean-all         - Remove all language containers and images"
	@echo ""
	@echo "  Supported languages: python, go, rust, ruby, commonlisp, scheme, bash, and more"
	@echo ""
	@echo "Test Endpoints (via environment variables):"
	@echo "  MODEL_ENDPOINT_1: $(MODEL_ENDPOINT_1)"
	@echo "  MODEL_ENDPOINT_2: $(MODEL_ENDPOINT_2)"
	@echo "  TTS_ENDPOINT_1:   $(TTS_ENDPOINT_1)"

.PHONY: languages-list
languages-list:
	@echo "Available language directories:"
	@ls -1 $(LANGUAGES_DIR)/

# Python language targets
.PHONY: languages-build-python
languages-build-python:
	docker build -t $(IMAGE_PREFIX)-python $(LANGUAGES_DIR)/python/requests/

.PHONY: languages-test-python
languages-test-python:
	@echo "Testing Python implementation..."
	docker run --rm $(DOCKER_ENV) $(IMAGE_PREFIX)-python

.PHONY: languages-run-python
languages-run-python:
	docker run -it --rm --name test-python $(IMAGE_PREFIX)-python

.PHONY: languages-stop-python
languages-stop-python:
	docker stop test-python || true
	docker rm test-python || true

.PHONY: languages-clean-python
languages-clean-python: languages-stop-python
	docker rmi $(IMAGE_PREFIX)-python || true

# Go language targets
.PHONY: languages-build-go
languages-build-go:
	docker build -t $(IMAGE_PREFIX)-go $(LANGUAGES_DIR)/go/http/

.PHONY: languages-test-go
languages-test-go:
	@echo "Testing Go implementation..."
	docker run --rm $(DOCKER_ENV) $(IMAGE_PREFIX)-go

.PHONY: languages-run-go
languages-run-go:
	docker run -it --rm --name test-go $(IMAGE_PREFIX)-go

.PHONY: languages-stop-go
languages-stop-go:
	docker stop test-go || true
	docker rm test-go || true

.PHONY: languages-clean-go
languages-clean-go: languages-stop-go
	docker rmi $(IMAGE_PREFIX)-go || true

# JavaScript/Node.js language targets
.PHONY: languages-build-js
languages-build-js:
	docker build -t $(IMAGE_PREFIX)-js $(LANGUAGES_DIR)/javascript/nodejs/

.PHONY: languages-test-js
languages-test-js:
	@echo "Testing JavaScript implementation..."
	docker run --rm $(DOCKER_ENV) $(IMAGE_PREFIX)-js

.PHONY: languages-run-js
languages-run-js:
	docker run -it --rm --name test-js $(IMAGE_PREFIX)-js

.PHONY: languages-stop-js
languages-stop-js:
	docker stop test-js || true
	docker rm test-js || true

.PHONY: languages-clean-js
languages-clean-js: languages-stop-js
	docker rmi $(IMAGE_PREFIX)-js || true

# Rust language targets
.PHONY: languages-build-rust
languages-build-rust:
	docker build -t $(IMAGE_PREFIX)-rust $(LANGUAGES_DIR)/rust/

.PHONY: languages-test-rust
languages-test-rust:
	@echo "Testing Rust implementation..."
	docker run --rm $(DOCKER_ENV) $(IMAGE_PREFIX)-rust

.PHONY: languages-run-rust
languages-run-rust:
	docker run -it --rm --name test-rust $(IMAGE_PREFIX)-rust

.PHONY: languages-stop-rust
languages-stop-rust:
	docker stop test-rust || true
	docker rm test-rust || true

.PHONY: languages-clean-rust
languages-clean-rust: languages-stop-rust
	docker rmi $(IMAGE_PREFIX)-rust || true

# Ruby language targets
.PHONY: languages-build-ruby
languages-build-ruby:
	docker build -t $(IMAGE_PREFIX)-ruby $(LANGUAGES_DIR)/ruby/http/

.PHONY: languages-test-ruby
languages-test-ruby:
	@echo "Testing Ruby implementation..."
	docker run --rm $(DOCKER_ENV) $(IMAGE_PREFIX)-ruby

.PHONY: languages-run-ruby
languages-run-ruby:
	docker run -it --rm --name test-ruby $(IMAGE_PREFIX)-ruby

.PHONY: languages-stop-ruby
languages-stop-ruby:
	docker stop test-ruby || true
	docker rm test-ruby || true

.PHONY: languages-clean-ruby
languages-clean-ruby: languages-stop-ruby
	docker rmi $(IMAGE_PREFIX)-ruby || true

# C language targets
.PHONY: languages-build-c
languages-build-c:
	docker build -t $(IMAGE_PREFIX)-c $(LANGUAGES_DIR)/c/curl/

.PHONY: languages-test-c
languages-test-c:
	@echo "Testing C implementation..."
	docker run --rm $(DOCKER_ENV) $(IMAGE_PREFIX)-c

.PHONY: languages-run-c
languages-run-c:
	docker run -it --rm --name test-c $(IMAGE_PREFIX)-c

.PHONY: languages-stop-c
languages-stop-c:
	docker stop test-c || true
	docker rm test-c || true

.PHONY: languages-clean-c
languages-clean-c: languages-stop-c
	docker rmi $(IMAGE_PREFIX)-c || true

# C++ language targets
.PHONY: languages-build-cpp
languages-build-cpp:
	docker build -t $(IMAGE_PREFIX)-cpp $(LANGUAGES_DIR)/cpp/libcurl/

.PHONY: languages-test-cpp
languages-test-cpp:
	@echo "Testing C++ implementation..."
	docker run --rm $(DOCKER_ENV) $(IMAGE_PREFIX)-cpp

.PHONY: languages-run-cpp
languages-run-cpp:
	docker run -it --rm --name test-cpp $(IMAGE_PREFIX)-cpp

.PHONY: languages-stop-cpp
languages-stop-cpp:
	docker stop test-cpp || true
	docker rm test-cpp || true

.PHONY: languages-clean-cpp
languages-clean-cpp: languages-stop-cpp
	docker rmi $(IMAGE_PREFIX)-cpp || true

# Bash language targets
.PHONY: languages-build-bash
languages-build-bash:
	docker build -t $(IMAGE_PREFIX)-bash $(LANGUAGES_DIR)/bash/

.PHONY: languages-test-bash
languages-test-bash:
	@echo "Testing Bash implementation..."
	docker run --rm $(DOCKER_ENV) $(IMAGE_PREFIX)-bash

.PHONY: languages-run-bash
languages-run-bash:
	docker run -it --rm --name test-bash $(IMAGE_PREFIX)-bash

.PHONY: languages-stop-bash
languages-stop-bash:
	docker stop test-bash || true
	docker rm test-bash || true

.PHONY: languages-clean-bash
languages-clean-bash: languages-stop-bash
	docker rmi $(IMAGE_PREFIX)-bash || true

# Common Lisp language targets
.PHONY: languages-build-commonlisp
languages-build-commonlisp:
	docker build -t $(IMAGE_PREFIX)-commonlisp $(LANGUAGES_DIR)/commonlisp/

.PHONY: languages-test-commonlisp
languages-test-commonlisp:
	@echo "Testing Common Lisp implementation..."
	docker run --rm $(DOCKER_ENV) $(IMAGE_PREFIX)-commonlisp

.PHONY: languages-run-commonlisp
languages-run-commonlisp:
	docker run -it --rm --name test-commonlisp $(IMAGE_PREFIX)-commonlisp

.PHONY: languages-stop-commonlisp
languages-stop-commonlisp:
	docker stop test-commonlisp || true
	docker rm test-commonlisp || true

.PHONY: languages-clean-commonlisp
languages-clean-commonlisp: languages-stop-commonlisp
	docker rmi $(IMAGE_PREFIX)-commonlisp || true

# Scheme language targets
.PHONY: languages-build-scheme
languages-build-scheme:
	docker build -t $(IMAGE_PREFIX)-scheme $(LANGUAGES_DIR)/scheme/

.PHONY: languages-test-scheme
languages-test-scheme:
	@echo "Testing Scheme implementation..."
	docker run --rm $(DOCKER_ENV) $(IMAGE_PREFIX)-scheme

.PHONY: languages-run-scheme
languages-run-scheme:
	docker run -it --rm --name test-scheme $(IMAGE_PREFIX)-scheme

.PHONY: languages-stop-scheme
languages-stop-scheme:
	docker stop test-scheme || true
	docker rm test-scheme || true

.PHONY: languages-clean-scheme
languages-clean-scheme: languages-stop-scheme
	docker rmi $(IMAGE_PREFIX)-scheme || true

# Build all language implementations
.PHONY: languages-build-all
languages-build-all:
	@echo "Building all language implementations..."
	@for lang in $(LANGUAGES); do \
		echo "Building $$lang..."; \
		docker build -t $(IMAGE_PREFIX)-$$lang languages/$$lang/ || echo "Failed to build $$lang"; \
	done

# Test all language implementations
.PHONY: languages-test-all
languages-test-all:
	@echo "Testing all language implementations..."
	@for lang in $(LANGUAGES); do \
		echo "Testing $$lang..."; \
		docker run --rm $(IMAGE_PREFIX)-$$lang || echo "Failed to test $$lang"; \
	done

# Stop all language containers
.PHONY: languages-stop-all
languages-stop-all:
	@echo "Stopping all language containers..."
	@for lang in $(LANGUAGES); do \
		docker stop test-$$lang 2>/dev/null || true; \
		docker rm test-$$lang 2>/dev/null || true; \
	done

# Clean all language containers and images
.PHONY: languages-clean-all
languages-clean-all: languages-stop-all
	@echo "Removing all language images..."
	@for lang in $(LANGUAGES); do \
		docker rmi $(IMAGE_PREFIX)-$$lang 2>/dev/null || true; \
	done