Adding a New Destination

protocol SyncDestination: Identifiable, Codable {
    var id: UUID { get }
    var name: String { get }
    var isEnabled: Bool { get set }
    func sync(data: [HealthDataPoint]) async throws
    func testConnection() async throws -> Bool
}

import Foundation

struct CSVExportDestination: SyncDestination {
    let id: UUID
    var name: String
    var isEnabled: Bool
    var exportDirectory: URL

    init(
        id: UUID = UUID(),
        name: String = "CSV Export",
        isEnabled: Bool = true,
        exportDirectory: URL
    ) {
        self.id = id
        self.name = name
        self.isEnabled = isEnabled
        self.exportDirectory = exportDirectory
    }

    func sync(data: [HealthDataPoint]) async throws {
        let dateFormatter = ISO8601DateFormatter()
        var csvContent = "metric,value,unit,timestamp\n"

        for point in data {
            let timestamp = dateFormatter.string(from: point.timestamp)
            csvContent += "\(point.metricType.rawValue),\(point.value),\(point.unit),\(timestamp)\n"
        }

        let fileName = "healthpush-\(dateFormatter.string(from: Date())).csv"
        let fileURL = exportDirectory.appendingPathComponent(fileName)
        try csvContent.write(to: fileURL, atomically: true, encoding: .utf8)
    }

    func testConnection() async throws -> Bool {
        // Verify we can write to the export directory
        let testFile = exportDirectory.appendingPathComponent(".healthpush-test")
        do {
            try "test".write(to: testFile, atomically: true, encoding: .utf8)
            try FileManager.default.removeItem(at: testFile)
            return true
        } catch {
            return false
        }
    }
}

// Add to the list of available destination types
enum DestinationType: String, CaseIterable, Codable {
    case homeAssistant
    case csvExport  // Add this
}

import SwiftUI

struct CSVExportSetupScreen: View {
    @State private var exportPath: String = ""
    @State private var testResult: Bool?

    var body: some View {
        Form {
            Section("Export Location") {
                TextField("Directory path", text: $exportPath)
            }

            Section {
                Button("Test Export") {
                    Task {
                        // Test writing to the directory
                    }
                }

                if let result = testResult {
                    Label(
                        result ? "Export directory is writable" : "Cannot write to directory",
                        systemImage: result ? "checkmark.circle.fill" : "xmark.circle.fill"
                    )
                    .foregroundStyle(result ? .green : .red)
                }
            }

            Section {
                Button("Save Destination") {
                    // Save via DestinationManager
                }
                .disabled(exportPath.isEmpty)
            }
        }
        .navigationTitle("CSV Export")
    }
}

import XCTest
@testable import HealthPush

final class CSVExportDestinationTests: XCTestCase {
    func testSyncWritesCSVFile() async throws {
        let tempDir = FileManager.default.temporaryDirectory
            .appendingPathComponent(UUID().uuidString)
        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)

        let destination = CSVExportDestination(exportDirectory: tempDir)
        let data = [
            HealthDataPoint(
                metricType: .steps,
                value: 1000,
                unit: "steps",
                timestamp: Date()
            )
        ]

        try await destination.sync(data: data)

        let files = try FileManager.default.contentsOfDirectory(
            at: tempDir,
            includingPropertiesForKeys: nil
        )
        XCTAssertEqual(files.count, 1)
        XCTAssertTrue(files[0].lastPathComponent.hasSuffix(".csv"))

        // Clean up
        try FileManager.default.removeItem(at: tempDir)
    }

    func testConnectionSucceedsForWritableDirectory() async throws {
        let tempDir = FileManager.default.temporaryDirectory
        let destination = CSVExportDestination(exportDirectory: tempDir)
        let result = try await destination.testConnection()
        XCTAssertTrue(result)
    }
}