A!leys Galerie

import SwiftUI
import CoreData

// MARK: - Data Model
extension MoodJotApp {
    @MainActor static func deleteModels() {
        let container = try! persistentContainer()
        let context = container.viewContext
        if let models = try? context.fetch(MoodJot.self) {
            for model in models {
                context.delete(model)
            }
        }
        try! context.save()
    }
}

@MainActor let persistentContainer: NSPersistentContainer = {
    let container = NSPersistentContainer(name: "MoodJotModel")
    container.loadPersistentStores { _, error in }
    return container
}()

// MARK: - Core Data Model Extension
extension MoodJot {
    static func createNote(title: String, content: String, mood: String, timestamp: Date) -> MoodJot {
        let note = MoodJot(context: persistentContainer.viewContext)
        note.title = title
        note.content = content
        note.mood = mood
        note.timestamp = timestamp
        return note
    }
}

// MARK: - MoodJot App Structure
@main
struct MoodJotApp: App {
    var body: some Scene {
        WindowGroup {
            NotesListView()
        }
    }
}

// MARK: - Notes List View
struct NotesListView: View {
    @StateObject private var viewModel = NotesViewModel()
    @State private var isAddingNote = false

    var body: some View {
        NavigationStack {
            List {
                ForEach(viewModel.notes) { note in
                    NavigationLink {
                        NoteDetailView(note: note)
                    } label: {
                        VStack(alignment: .leading) {
                            Text(note.title)
                                .font(.headline)
                            Text(note.content.prefix(30) + (note.content.count > 30 ? "..." : ""))
                                .font(.subheadline)
                                .foregroundColor(.secondary)
                            HStack {
                                Text(note.mood)
                                    .font(.caption)
                                    .padding(4)
                                    .background(Capsule().fill(moodColor(note.mood)))
                                Text(note.timestamp, style: .date)
                                    .font(.caption)
                                    .foregroundColor(.secondary)
                            }
                        }
                        .padding(.vertical, 4)
                    }
                }
                .onDelete { indices in
                    viewModel.deleteNotes(at: indices)
                }
            }
            .navigationTitle("MoodJot")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: { isAddingNote = true }) {
                        Image(systemName: "plus")
                    }
                }
            }
            .sheet(isPresented: $isAddingNote) {
                AddNoteView(isPresented: $isAddingNote)
            }
            .task {
                viewModel.fetchNotes()
            }
        }
    }

    private func moodColor(_ mood: String) -> Color {
        switch mood.lowercased() {
        case "happy":
            return .green
        case "sad":
            return .blue
        case "angry":
            return .red
        case "excited":
            return .yellow
        case "relaxed":
            return .orange
        default:
            return .gray
        }
    }
}

// MARK: - Add Note View
struct AddNoteView: View {
    @Binding var isPresented: Bool
    @State private var title = ""
    @State private var content = ""
    @State private var mood = "happy"

    var body: some View {
        NavigationStack {
            Form {
                Section(header: Text("Title")) {
                    TextField("Note Title", text: $title)
                }

                Section(header: Text("Content")) {
                    TextEditor(text: $content)
                        .tint(.blue)
                }

                Section(header: Text("Mood")) {
                    Picker("Mood", selection: $mood) {
                        ForEach(["Happy", "Sad", "Angry", "Excited", "Relaxed"], id: \.self) { moodOption in
                            Text(moodOption).tag(moodOption.lowercased())
                        }
                    }
                    .pickerStyle(.menu)
                }
            }
            .navigationTitle("New Note")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .confirmationAction) {
                    Button("Save") {
                        let timestamp = Date()
                        let note = MoodJot.createNote(title: title, content: content, mood: mood, timestamp: timestamp)
                        persistentContainer.viewContext.insert(note)
                        try? persistentContainer.viewContext.save()
                        isPresented = false
                    }
                    .disabled(title.isEmpty || content.isEmpty)
                }
            }
        }
    }
}

// MARK: - Note Detail View
struct NoteDetailView: View {
    let note: MoodJot

    var body: some View {
        ScrollView {
            VStack(alignment: .leading, spacing: 16) {
                Text(note.title)
                    .font(.title)
                    .bold()

                Capsule()
                    .fill(moodColor(note.mood))
                    .frame(width: 30, height: 30)
                    .overlay(
                        Text(note.mood.capitalized)
                            .font(.caption)
                            .foregroundColor(.white)
                    )

                Text(note.content)
                    .font(.body)

                Spacer()

                HStack {
                    Text("Created: ")
                        .foregroundColor(.secondary)
                    Text(note.timestamp, style: .date)
                }
                .padding(.top)
            }
            .padding()
        }
        .navigationTitle("Note")
        .navigationBarTitleDisplayMode(.inline)
    }

    private func moodColor(_ mood: String) -> Color {
        switch mood.lowercased() {
        case "happy":
            return .green
        case "sad":
            return .blue
        case "angry":
            return .red
        case "excited":
            return .yellow
        case "relaxed":
            return .orange
        default:
            return .gray
        }
    }
}

// MARK: - ViewModel
@MainActor class NotesViewModel: ObservableObject {
    @Published var notes: [MoodJot] = []

    func fetchNotes() {
        let request = NSFetchRequest<MoodJot>(entityName: "MoodJot")
        request.sortDescriptors = [NSSortDescriptor(keyPath: \MoodJot.timestamp, ascending: false)]
        notes = (try? persistentContainer.viewContext.fetch(request)) ?? []
    }

    func deleteNotes(at offsets: IndexSet) {
        for index in offsets {
            let note = notes[index]
            persistentContainer.viewContext.delete(note)
        }
        try? persistentContainer.viewContext.save()
        fetchNotes()
    }
}

// MARK: - Previews
#Preview {
    NotesListView()
}

// Dynamic NPC Behavior Simulator for RPG Maker MZ
// Features:
// - Simulates 3 different NPC behaviors (Explorer, Trader, Hermit)
// - Visualizes behavior patterns in a simple terminal UI
// - Saves NPC configurations to localStorage
// - Randomizes certain traits while maintaining personality archetypes

import readline from 'readline';

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

class NPCCore {
    constructor(name, behaviorType, traits) {
        this.name = name || `NPC-${Math.floor(Math.random() * 1000)}`;
        this.behaviorType = behaviorType || this.randomBehaviorType();
        this.traits = traits || this.generateTraits(this.behaviorType);
        this.memory = [];
        this.energy = 100;
        this.timeSinceLastAction = 0;
    }

    randomBehaviorType() {
        const types = ['Explorer', 'Trader', 'Hermit'];
        return types[Math.floor(Math.random() * types.length)];
    }

    generateTraits(behaviorType) {
        const baseTraits = {
            curiosity: Math.floor(Math.random() * 41) + 30,  // 30-70
            sociability: Math.floor(Math.random() * 41) + 30,
            routine: Math.floor(Math.random() * 41) + 30,
            greed: Math.floor(Math.random() * 41) + 10,      // 10-50
            knowledge: Math.floor(Math.random() * 41) + 20,  // 20-60
            introversion: Math.floor(Math.random() * 41) + 20 // 20-60
        };

        switch (behaviorType) {
            case 'Explorer':
                return {
                    ...baseTraits,
                    curiosity: Math.min(90, baseTraits.curiosity + 20),
                    knowledge: Math.min(80, baseTraits.knowledge + 10),
                    sociability: Math.max(30, baseTraits.sociability - 10)
                };
            case 'Trader':
                return {
                    ...baseTraits,
                    greed: Math.min(80, baseTraits.greed + 30),
                    sociability: Math.min(80, baseTraits.sociability + 20),
                    routine: Math.max(30, baseTraits.routine - 10)
                };
            case 'Hermit':
                return {
                    ...baseTraits,
                    introversion: Math.min(80, baseTraits.introversion + 20),
                    routine: Math.min(80, baseTraits.routine + 20),
                    sociability: Math.max(20, baseTraits.sociability - 20)
                };
            default:
                return baseTraits;
        }
    }

    update(timePassed) {
        this.timeSinceLastAction += timePassed;
        this.energy -= timePassed * 0.1;

        if (this.energy < 0) this.energy = 0;

        // Behavior-specific updates
        switch (this.behaviorType) {
            case 'Explorer':
                this.explorerBehaviorUpdate(timePassed);
                break;
            case 'Trader':
                this.traderBehaviorUpdate(timePassed);
                break;
            case 'Hermit':
                this.hermitBehaviorUpdate(timePassed);
                break;
        }

        // Random events that might trigger
        if (Math.random() < 0.01 * (1 + this.traits.curiosity / 100)) {
            this.memory.push(`[Discovered ${this.generateDiscovery()}]`);
        }
    }

    explorerBehaviorUpdate(timePassed) {
        // Explorers get energy from discovering new places
        if (Math.random() < 0.02 * (this.traits.curiosity / 100)) {
            this.energy += 5;
            this.memory.push(`[Found interesting artifact near ${this.generateLocation()}]`);
        }

        // They wander more when curious
        if (this.timeSinceLastAction > 10 + (100 - this.traits.curiosity) / 2) {
            this.performAction('Wander to new location');
            this.timeSinceLastAction = 0;
        }
    }

    traderBehaviorUpdate(timePassed) {
        // Traders gain energy from trading
        if (Math.random() < 0.03 * (this.traits.greed / 100) && this.traits.routine > 50) {
            const profit = Math.floor(Math.random() * 11) - 5;
            this.energy += Math.max(3, profit);
            this.memory.push(`[Traded for ${profit >= 0 ? 'profit' : 'loss'} of ${Math.abs(profit)} gold]`);
        }

        // They get restless if routine is low
        if (this.timeSinceLastAction > 8 - (this.traits.routine / 20)) {
            if (Math.random() < 0.3 * (100 - this.traits.sociability) / 100) {
                this.performAction('Seek out other traders');
            } else {
                this.performAction('Restock inventory');
            }
            this.timeSinceLastAction = 0;
        }
    }

    hermitBehaviorUpdate(timePassed) {
        // Hermits gain energy from routine
        if (Math.random() < 0.01 * (this.traits.routine / 100)) {
            this.energy += 2;
            this.memory.push(`[Completed daily routine task]`);
        }

        // They get uncomfortable with too much interaction
        if (this.timeSinceLastAction > 12 + (this.traits.introversion / 3)) {
            if (Math.random() < 0.7 * (this.traits.introversion / 100)) {
                this.performAction('Return to solitary spot');
            } else {
                this.performAction('Observe from a distance');
            }
            this.timeSinceLastAction = 0;
        }
    }

    performAction(action) {
        this.memory.push(`[${this.behaviorType}: ${action}]`);
        this.timeSinceLastAction = 0;
        this.energy += 2; // Small energy boost from activity
    }

    generateDiscovery() {
        const discoveries = [
            'ancient ruins',
            'rare herb',
            'mysterious map fragment',
            'glowing mineral',
            'forgotten text',
            'strange artifact',
            'hidden cave entrance'
        ];
        return discoveries[Math.floor(Math.random() * discoveries.length)];
    }

    generateLocation() {
        const locations = [
            'eastern forest',
            'western valley',
            'northern peaks',
            'southern marshes',
            'abandoned temple',
            'dusty library',
            'old market square'
        ];
        return locations[Math.floor(Math.random() * locations.length)];
    }

    toString() {
        return `[${this.behaviorType}] ${this.name} (Energy: ${Math.round(this.energy)} | ` +
               `Curiosity: ${this.traits.curiosity} | ` +
               `Sociability: ${this.traits.sociability} | ` +
               `Greed: ${this.traits.greed} | ` +
               `Knowledge: ${this.traits.knowledge})`;
    }
}

class SimulationManager {
    constructor() {
        this.npcs = [];
        this.time = 0;
        this.running = false;
        this.loadNPCs();
    }

    loadNPCs() {
        const savedNPCs = localStorage.getItem('rpgNPCBehavior');
        if (savedNPCs) {
            this.npcs = JSON.parse(savedNPCs);
        } else {
            // Create some default NPCs if none saved
            for (let i = 0; i < 3; i++) {
                const behaviorTypes = ['Explorer', 'Trader', 'Hermit'];
                this.npcs.push(new NPCCore(
                    `NPC${i + 1}`,
                    behaviorTypes[i % behaviorTypes.length]
                ));
            }
        }
    }

    saveNPCs() {
        localStorage.setItem('rpgNPCBehavior', JSON.stringify(this.npcs));
    }

    start() {
        this.running = true;
        this.simulate();
    }

    stop() {
        this.running = false;
    }

    simulate() {
        if (!this.running) return;

        // Clear screen (works in most terminals)
        console.log('\x1B[2J\x1B[0;0H');

        // Draw header
        console.log('='.repeat(50));
        console.log('DYNAMIC NPC BEHAVIOR SIMULATOR'.padEnd(50) + 'Time: ' + this.time);
        console.log('='.repeat(50));

        // Draw each NPC
        this.npcs.forEach(npc => {
            console.log('\n' + npc);
            console.log('-'.repeat(40));

            // Draw memory if there are entries
            if (npc.memory.length > 0) {
                console.log('Recent Memory:');
                console.log(npc.memory.slice(-5).join(' | ')); // Show last 5 entries
            }

            // Draw energy bar
            const energyBar = '#'.repeat(Math.floor(npc.energy / 2)) +
                              '-'.repeat(50 - Math.floor(npc.energy / 2));
            console.log(`Energy: [${energyBar}] ${Math.round(npc.energy)}/100`);
        });

        console.log('\n'.repeat(2));

        // Update NPCs
        this.npcs.forEach(npc => {
            npc.update(1); // Time passes at 1 unit per simulation step
        });

        this.time++;
        this.saveNPCs();

        // Continue simulation
        if (this.running) {
            setTimeout(() => this.simulate(), 1000);
        } else {
            console.log('\nSimulation stopped.');
        }
    }

    addNPC(name, behaviorType) {
        this.npcs.push(new NPCCore(name, behaviorType));
        this.saveNPCs();
    }

    removeNPC(index) {
        if (index >= 0 && index < this.npcs.length) {
            this.npcs.splice(index, 1);
            this.saveNPCs();
        }
    }

    showMenu() {
        console.log('\nCOMMANDS:');
        console.log('  start - Start/Resume simulation');
        console.log('  stop - Stop simulation');
        console.log('  add [name] [type] - Add new NPC (e.g., "add Gandalf Explorer")');
        console.log('  remove [index] - Remove NPC by index (0-based)');
        console.log('  quit - Exit program');
        console.log('  clear - Clear console (but keeps simulation running)');
        console.log('  help - Show this menu');
    }
}

// Main program
const manager = new SimulationManager();
manager.showMenu();

rl.on('line', (line) => {
    const command = line.trim().toLowerCase();

    if (command === 'start') {
        if (!manager.running) {
            manager.start();
            console.log('Simulation started...');
        } else {
            console.log('Simulation is already running.');
        }
    } else if (command === 'stop') {
        manager.stop();
    } else if (command === 'quit') {
        manager.stop();
        rl.close();
        process.exit();
    } else if (command === 'clear') {
        console.log('\x1B[2J\x1B[0;0H');
    } else if (command === 'help') {
        manager.showMenu();
    } else if (command.startsWith('add ')) {
        const parts = line.split(' ');
        if (parts.length === 3) {
            const name = parts[1];
            const type = parts[2];
            if (['explorer', 'trader', 'hermit'].includes(type.toLowerCase())) {
                manager.addNPC(name, type.charAt(0).toUpperCase() + type.slice(1));
                console.log(`Added ${name} as a ${type} NPC.`);
            } else {
                console.log('Invalid behavior type. Use: Explorer, Trader, Hermit');
            }
        } else {
            console.log('Usage: add [name] [type]');
        }
    } else if (command.startsWith('remove ')) {
        const index = parseInt(line.split(' ')[1]);
        if (!isNaN(index)) {
            manager.removeNPC(index);
            console.log(`Removed NPC at index ${index}.`);
        } else {
            console.log('Please provide a valid index number.');
        }
    } else if (command === '') {
        // Ignore empty lines
        return;
    } else {
        console.log('Unknown command. Type "help" for available commands.');
    }
});

// Handle exit signal
process.on('SIGINT', () => {
    manager.stop();
    rl.close();
    process.exit();
});