# List of phony targets (targets that don't represent files)
.PHONY: all clean venv run format format-check lint mypy test dist reformat dev celery celery-flower redis run-all

# Define Python and pip executables inside virtual environment
PYTHON := venv/bin/python
PIP := venv/bin/pip

# Celery worker command
CELERY := venv/bin/celery

# Default target that runs the application
all: run

# Remove all generated files and directories
clean:
	rm -rf venv build dist .pytest_cache .mypy_cache *.egg-info

# Define database path
DB_PATH=scipaperloader/papers.db

# Backup the database with timestamp
backup-db:
	@mkdir -p backups
	@timestamp=$$(date +%Y%m%d_%H%M%S); \
	cp $(DB_PATH) backups/papers_$$timestamp.db && \
	echo "Database backed up to backups/papers_$$timestamp.db"

# Create sample test data for development and testing
sample-data: venv
	$(PYTHON) scipaperloader/scripts/create_sample_data.py

# Export database as SQL script with timestamp
export-db: venv
	@mkdir -p exports
	@timestamp=$$(date +%Y%m%d_%H%M%S); \
	$(PYTHON) -c "import sqlite3; conn = sqlite3.connect('$(DB_PATH)'); with open('exports/papers_$$timestamp.sql', 'w') as f: f.write(''.join(conn.iterdump()));" && \
	echo "Database exported to exports/papers_$$timestamp.sql"

# Run the application with production settings
run-prod: venv
	FLASK_ENV=production venv/bin/flask --app scipaperloader run --host=0.0.0.0

# Check for security vulnerabilities in dependencies
security-check: venv
	$(PIP) install safety
	venv/bin/safety check

# Create a new database migration with provided message
db-migrate: venv
	venv/bin/flask --app scipaperloader db migrate -m "$(message)"

# Apply pending database migrations
db-upgrade: venv
	venv/bin/flask --app scipaperloader db upgrade

# Revert the last database migration
db-downgrade: venv
	venv/bin/flask --app scipaperloader db downgrade

# Generate API documentation using Sphinx
docs: venv
	$(PIP) install sphinx sphinx_rtd_theme
	cd docs && venv/bin/sphinx-build -b html source build

# Create a code coverage report for the test suite
coverage: venv
	$(PYTHON) -m pytest --cov=scipaperloader --cov-report=html
	@echo "Coverage report generated in htmlcov/"

# Generate a requirements.txt file from current environment
requirements: venv
	$(PIP) freeze > requirements.txt
	@echo "Requirements file updated"

# Show project statistics (code lines, routes, database size)
stats:
	@echo "Lines of Python code:"
	@find scipaperloader -name "*.py" | xargs wc -l | sort -nr
	@echo "Number of routes:"
	@grep -r "@bp.route" scipaperloader | wc -l
	@echo "Database file size:"
	@du -h $(DB_PATH) 2>/dev/null || echo "Database file not found"

# Show TODOs and FIXMEs in code
todos:
	@grep -r "TODO\|FIXME" scipaperloader || echo "No TODOs found"

# Reset the database: delete, initialize, and migrate
reset-db: venv
	rm -f $(DB_PATH)
	$(PYTHON) -m flask --app scipaperloader db init || true
	$(PYTHON) -m flask --app scipaperloader db migrate -m "Initial migration"
	$(PYTHON) -m flask --app scipaperloader db upgrade

# Create and set up virtual environment
venv:
	python3 -m venv venv && \
		$(PIP) install --upgrade pip setuptools && \
		$(PIP) install --editable ".[dev]"

# Run the application in debug mode
run: venv
	venv/bin/flask --app scipaperloader --debug run

# Format code using Black and isort
format:
	venv/bin/black .
	venv/bin/isort .

# Check if code meets formatting standards
format-check:
	venv/bin/black --check .
	venv/bin/isort --check .

# Reformat and lint code
reformat: format lint

# Check code for style issues using flake8
lint:
	venv/bin/flake8 .

# Run static type checking with mypy
mypy:
	venv/bin/mypy scipaperloader

# Run the test suite
test:
	venv/bin/pytest

# Build distribution package after running checks
dist: format-check lint mypy test
	$(PIP) wheel --wheel-dir dist --no-deps .

# Set up complete development environment
dev: clean venv

# Start Celery worker for processing tasks
celery: venv
	$(CELERY) -A celery_worker:celery worker --loglevel=info
    
# Monitor Celery tasks with flower web interface
celery-flower: venv
	$(PIP) install flower
	$(CELERY) -A celery_worker:celery flower --port=5555

# Check if Redis is running, start if needed
redis:
	@redis-cli ping > /dev/null 2>&1 || (echo "Starting Redis server..." && redis-server --daemonize yes)

# Run complete application stack (Flask app + Celery worker + Redis)
run-all: redis
	@echo "Starting Flask and Celery..."
	@$(MAKE) -j2 run celery