A!leys Galerie

import SwiftUI
import Charts

// MARK: - Models
struct Expense: Identifiable {
    let id = UUID()
    let name: String
    let amount: Double
    let date: Date
    let category: ExpenseCategory
    var isFavorited: Bool = false

    var formattedDate: String {
        let formatter = DateFormatter()
        formatter.dateStyle = .medium
        return formatter.string(from: date)
    }
}

enum ExpenseCategory: String, CaseIterable, Identifiable {
    case food = "🍽️ Food"
    case shopping = "🛍️ Shopping"
    case transport = "🚗 Transport"
    case entertainment = "🎬 Entertainment"
    case other = "📝 Other"

    var id: String { rawValue }
    var color: Color {
        switch self {
        case .food: return .orange
        case .shopping: return .purple
        case .transport: return .blue
        case .entertainment: return .pink
        case .other: return .gray
        }
    }
}

// MARK: - Core ViewModel
class ExpenseViewModel: ObservableObject {
    @Published var expenses: [Expense] = []
    @Published var selectedCategory: ExpenseCategory = .food
    @Published var isShowingAddExpense: Bool = false

    private let expensesKey = "savedExpenses"

    init() {
        loadExpenses()
    }

    func addExpense(name: String, amount: String, category: ExpenseCategory, date: Date) {
        guard let amount = Double(amount) else { return }

        let newExpense = Expense(
            name: name,
            amount: amount,
            date: date,
            category: category
        )

        expenses.append(newExpense)
        saveExpenses()
    }

    func toggleFavorite(_ expense: Expense) {
        if let index = expenses.firstIndex(where: { $0.id == expense.id }) {
            expenses[index].isFavorited.toggle()
            saveExpenses()
        }
    }

    func deleteExpense(_ expense: Expense) {
        expenses.removeAll { $0.id == expense.id }
        saveExpenses()
    }

    private func saveExpenses() {
        if let encoded = try? JSONEncoder().encode(expenses) {
            UserDefaults.standard.set(encoded, forKey: expensesKey)
        }
    }

    private func loadExpenses() {
        if let data = UserDefaults.standard.data(forKey: expensesKey),
           let decoded = try? JSONDecoder().decode([Expense].self, from: data) {
            expenses = decoded
        }
    }
}

// MARK: - Main Content View
struct ExpenseFlowView: View {
    @StateObject private var viewModel = ExpenseViewModel()
    @State private var showingChartOptions = false

    var body: some View {
        NavigationStack {
            ZStack(alignment: .bottom) {
                // Main List with custom backdrop
                ScrollView {
                    VStack(spacing: 0) {
                        headerSection
                        ChartSection(showingChartOptions: $showingChartOptions)
                        mainListSection
                    }
                }
                .background(
                    LinearGradient(
                        gradient: Gradient(colors: [.clear, Color(red: 0.95, green: 0.95, blue: 1.0)]),
                        startPoint: .top,
                        endPoint: .bottom
                    )
                )
                .navigationTitle("ExpenseFlow")
                .navigationBarTitleDisplayMode(.inline)

                // Floating Add Button
                VStack {
                    Spacer()
                    HStack {
                        Spacer()
                        addExpenseButton
                            .padding(.vertical, 16)
                            .padding(.trailing, 24)
                    }
                }
            }
        }
    }

    // MARK: - Sections

    private var headerSection: some View {
        VStack {
            // Weekly Stats
            HStack {
                Text("This Week")
                    .font(.subheadline)
                    .foregroundStyle(.secondary)

                Spacer()

                Text("\(weeklyTotal, specifier: "%.2f")")
                    .font(.title2)
                    .fontWeight(.bold)
                    .foregroundStyle(.primary)

                Text("Total")
                    .font(.subheadline)
                    .foregroundStyle(.secondary)
            }
            .padding(.horizontal)

            // Progress Ring
            progressRing
                .padding(.horizontal)
                .padding(.bottom)
        }
    }

    private var progressRing: some View {
        ZStack {
            Circle()
                .stroke(lineWidth: 6)
                .opacity(0.3)
                .foregroundColor(.blue)

            Circle()
                .trim(from: 0, to: min(weeklyTotal / 100, 1))
                .stroke(
                    style: StrokeStyle(lineWidth: 6, lineCap: .round)
                )
                .foregroundColor(.blue)
                .rotationEffect(.degrees(-90))
                .animation(.easeInOut(duration: 1), value: weeklyTotal)

            Circle()
                .frame(width: 120, height: 120)
                .background(Color.clear)
        }
        .overlay(
            VStack {
                Text("\(Int(weeklyTotal))")
                    .font(.system(size: 12, weight: .bold))

                Text("Goal")
                    .font(.system(size: 10))
            }
        )
    }

    private var mainListSection: some View {
        VStack(alignment: .leading, spacing: 0) {
            // Category Filter
            Picker("Filter by category", selection: $viewModel.selectedCategory) {
                ForEach(ExpenseCategory.allCases) { category in
                    Text(category.rawValue)
                        .tag(category)
                }
            }
            .pickerStyle(.segmented)
            .padding(.horizontal)

            // Filtered Expenses
            ForEach(filteredExpenses) { expense in
                ExpenseRow(expense: expense, viewModel: viewModel)
            }

            if filteredExpenses.isEmpty {
                Text("No expenses yet for this category")
                    .foregroundStyle(.secondary)
                    .font(.subheadline)
                    .frame(maxWidth: .infinity, alignment: .center)
                    .padding(.vertical, 16)
            }
        }
    }

    // MARK: - Computed Properties

    private var weeklyTotal: Double {
        let now = Date()
        let calendar = Calendar.current
        let weekStart = calendar.startOfSymperiod(in: .weekOfYear, for: now)
        let weekEnd = calendar.date(byAdding: .day, value: 6, to: weekStart)!

        return viewModel.expenses
            .filter { expense in
                calendar.isDate(expense.date, inSameDayAs: weekStart) ||
                calendar.isDate(expense.date, inSameDayAs: weekEnd)
            }
            .reduce(0) { $0 + $1.amount }
    }

    private var filteredExpenses: [Expense] {
        viewModel.expenses.filter { $0.category == viewModel.selectedCategory }
    }

    // MARK: - Subviews

    private var addExpenseButton: some View {
        Button {
            viewModel.isShowingAddExpense = true
        } label: {
            Label("Add Expense", systemImage: "plus.circle.fill")
                .labelStyle(.iconOnly)
                .font(.title3)
                .foregroundColor(.blue)
        }
    }
}

// MARK: - Subviews

struct ExpenseRow: View {
    let expense: Expense
    @ObservedObject var viewModel: ExpenseViewModel

    var body: some View {
        HStack {
            // Category Color + Icon
            Circle()
                .fill(expense.category.color)
                .frame(width: 32, height: 32)
                .overlay {
                    Text(expense.category.rawValue.components(separatedBy: CharacterSet controllCharacters.inverted).first ?? "")
                        .font(.caption)
                        .foregroundColor(.white)
                }

            VStack(alignment: .leading) {
                Text(expense.name)
                    .font(.subheadline)
                    .fontWeight(.medium)

                HStack {
                    Text("\(expense.formattedDate)")
                        .font(.caption)
                        .foregroundStyle(.secondary)

                    Spacer()

                    Text("\(expense.amount, specifier: "%.2f")")
                        .font(.subheadline)
                        .fontWeight(.semibold)
                        .foregroundStyle(expense.isFavorited ? .blue : .primary)
                }
                .font(.caption)
            }
            .padding(.leading, 8)

            Spacer()

            Button {
                viewModel.deleteExpense(expense)
            } label: {
                Image(systemName: "trash")
                    .foregroundColor(.secondary)
                    .frame(width: 24)
            }
        }
        .contentShape(Rectangle())
        .onTapGesture {
            withAnimation {
                viewModel.toggleFavorite(expense)
            }
        }
    }
}

struct ChartSection: View {
    @Binding var showingChartOptions: Bool
    @ObservedObject var viewModel: ExpenseViewModel

    init(showingChartOptions: Binding<Bool>, viewModel: ExpenseViewModel = ExpenseViewModel()) {
        self._showingChartOptions = showingChartOptions
        self.viewModel = viewModel
    }

    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            HStack {
                Text("Weekly Spending")
                    .font(.headline)

                Spacer()

                Button {
                    showingChartOptions.toggle()
                } label: {
                    Image(systemName: showingChartOptions ? "chevron.down" : "chevron.right")
                        .font(.caption)
                        .foregroundColor(.secondary)
                }
            }

            if showingChartOptions {
                ExpenseChart(expenses: viewModel.expenses)
                    .frame(height: 200)
                    .padding(.top, 8)
            }
        }
        .padding(.horizontal)
        .background(
            RoundedRectangle(cornerRadius: 8)
                .stroke(lineWidth: 1)
                .foregroundColor(Color(red: 0.9, green: 0.9, blue: 1.0))
        )
        .padding(.vertical, 8)
    }
}

struct ExpenseChart: View {
    let expenses: [Expense]

    var body: some View {
        Chart {
            ForEach(ExpenseCategory.allCases) { category in
                if let filtered = expenses.filter({ $0.category == category }).isEmpty ? nil : expenses.filter({ $0.category == category }) {
                    BarMark(
                        x: .value("Category", category.rawValue),
                        y: .value("Amount", filtered.reduce(0) { $0 + $1.amount })
                    )
                    .foregroundStyle(category.color)
                    .cornerRadius(4)
                }
            }
        }
        .chartXAxis {
            AxisMarks(values: .automatic)
        }
        .chartYAxis {
            AxisMarks(values: .automatic)
        }
        .frame(height: 200)
    }
}

// MARK: - Add Expense Sheet
struct AddExpenseView: View {
    @Environment(\.dismiss) var dismiss
    @ObservedObject var viewModel: ExpenseViewModel

    @State private var name = ""
    @State private var amount = ""
    @State private var selectedCategory = ExpenseCategory.food
    @State private var date = Date()

    var body: some View {
        NavigationStack {
            Form {
                Section(header: Text("Details")) {
                    TextField("Name", text: $name)
                    TextField("Amount", text: $amount)
                        .keyboardType(.decimalPad)

                    Picker("Category", selection: $selectedCategory) {
                        ForEach(ExpenseCategory.allCases) { category in
                            Text(category.rawValue)
                                .tag(category)
                        }
                    }

                    DatePicker("Date", selection: $date, displayedComponents: .date)
                }
            }
            .navigationTitle("Add Expense")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .confirmationAction) {
                    Button("Save") {
                        viewModel.addExpense(
                            name: name,
                            amount: amount,
                            category: selectedCategory,
                            date: date
                        )
                        dismiss()
                    }
                    .disabled(name.isEmpty || amount.isEmpty)
                }
            }
        }
    }
}

// MARK: - Preview
struct ExpenseFlowView_Previews: PreviewProvider {
    static var previews: some View {
        ExpenseFlowView()
            .previewLayout(.sizeThatFits)
            .previewInterfaceOrientation(.portrait)
    }
}

// MARK: - Preview Data Helper
struct PreviewDataHelper {
    static func sampleExpenses() -> [Expense] {
        let calendar = Calendar.current
        let now = Date()
        let oneDayAgo = calendar.date(byAdding: .day, value: -1, to: now)!
        let threeDaysAgo = calendar.date(byAdding: .day, value: -3, to: now)!

        return [
            Expense(name: "Coffee", amount: 3.5, date: oneDayAgo, category: .food),
            Expense(name: "Grocery", amount: 45.2, date: oneDayAgo, category: .food),
            Expense(name: "Clothes", amount: 89.99, date: threeDaysAgo, category: .shopping, isFavorited: true),
            Expense(name: "Transport", amount: 12.5, date: oneDayAgo, category: .transport),
            Expense(name: "Concert Tickets", amount: 75.0, date: threeDaysAgo, category: .entertainment),
            Expense(name: "Movie", amount: 12.99, date: Date(), category: .entertainment)
        ]
    }
}