ProfileManager.java

package model;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

public class ProfileManager {
    private static final Logger logger = Logger.getLogger(ProfileManager.class.getName());
    private final String FILE_PATH;
    private static final String DELIMITER = "\\|";
    private static final String LIST_DELIMITER = ",";

    // Field positions for consistent parsing
    private static final int ID_INDEX = 0;
    private static final int NAME_INDEX = 1;
    private static final int PROVIDER_TYPE_INDEX = 2;
    private static final int BIO_INDEX = 3;
    private static final int SPECIALTIES_INDEX = 4;
    private static final int AVAILABILITY_INDEX = 5;
    private static final int SAMPLE_MEDIA_INDEX = 6;
    private static final int RATING_INDEX = 7;

    public ProfileManager(String filePath) {
        this.FILE_PATH = filePath;
        logger.log(Level.INFO, "Initializing ProfileManager with file: {0}", filePath);
    }

    public void saveProfiles(List<ServiceProvider> providers) throws IOException {
        if (providers == null) {
            throw new IllegalArgumentException("Providers list cannot be null");
        }

        File file = new File(FILE_PATH);
        File parentDir = file.getParentFile();

        if (parentDir != null && !parentDir.exists() && !parentDir.mkdirs()) {
            throw new IOException("Failed to create directory for " + FILE_PATH);
        }

        try (BufferedWriter writer = new BufferedWriter(new FileWriter(file))) {
            for (ServiceProvider provider : providers) {
                String line = String.join("|",
                        provider.getId(),
                        provider.getName(),
                        provider.getProviderType(),
                        provider.getBio(),
                        String.join(LIST_DELIMITER, provider.getSpecialties()),
                        String.join(LIST_DELIMITER, provider.getAvailability()),
                        String.join(LIST_DELIMITER, provider.getSampleMedia()),
                        String.valueOf(provider.getRating())
                );
                writer.write(line);
                writer.newLine();
            }
            logger.log(Level.INFO, "Successfully saved {0} profiles", providers.size());
        } catch (IOException e) {
            logger.log(Level.SEVERE, "Error saving profiles", e);
            throw e;
        }
    }

    public List<ServiceProvider> loadProfiles() {
        List<ServiceProvider> providers = new ArrayList<>();
        File file = new File(FILE_PATH);

        if (!file.exists()) {
            logger.log(Level.WARNING, "Data file not found at: {0}", FILE_PATH);
            return providers;
        }

        if (file.length() == 0) {
            logger.log(Level.INFO, "Data file is empty");
            return providers;
        }

        try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
            String line;
            int lineNumber = 0;

            while ((line = reader.readLine()) != null) {
                lineNumber++;
                line = line.trim();
                if (line.isEmpty()) {
                    continue;
                }

                try {
                    String[] fields = line.split(DELIMITER, -1);
                    if (fields.length != 8) {
                        logger.log(Level.WARNING, "Invalid field count at line {0}. Expected 8, got {1}",
                                new Object[]{lineNumber, fields.length});
                        continue;
                    }

                    ServiceProvider provider = parseProvider(fields);
                    if (provider != null) {
                        providers.add(provider);
                    }
                } catch (Exception e) {
                    logger.log(Level.WARNING, "Error parsing line " + lineNumber, e);
                }
            }
            logger.log(Level.INFO, "Loaded {0} profiles from file", providers.size());
        } catch (IOException e) {
            logger.log(Level.SEVERE, "Error loading profiles", e);
        }

        return providers;
    }

    private ServiceProvider parseProvider(String[] fields) {
        try {
            String id = fields[ID_INDEX].trim();
            String name = fields[NAME_INDEX].trim();
            String providerType = fields[PROVIDER_TYPE_INDEX].trim();
            String bio = fields[BIO_INDEX].trim();

            List<String> specialties = parseList(fields[SPECIALTIES_INDEX]);
            List<String> availability = parseList(fields[AVAILABILITY_INDEX]);
            List<String> sampleMedia = parseList(fields[SAMPLE_MEDIA_INDEX]);

            double rating = parseRating(fields[RATING_INDEX]);

            if ("photographer".equalsIgnoreCase(providerType)) {
                return new Photographer(id, name, bio, specialties, availability, sampleMedia, rating);
            } else {
                return new Videographer(id, name, bio, specialties, availability, sampleMedia, rating);
            }
        } catch (Exception e) {
            logger.log(Level.WARNING, "Error parsing provider", e);
            return null;
        }
    }

    private List<String> parseList(String field) {
        if (field == null || field.trim().isEmpty()) {
            return new ArrayList<>();
        }
        return Arrays.asList(field.split(LIST_DELIMITER));
    }

    private double parseRating(String ratingField) {
        try {
            return Double.parseDouble(ratingField.trim());
        } catch (NumberFormatException e) {
            logger.log(Level.WARNING, "Invalid rating value: {0}", ratingField);
            return 0.0;
        }
    }

    public void addProfile(ServiceProvider provider) throws IOException {
        if (provider == null) {
            throw new IllegalArgumentException("Provider cannot be null");
        }

        List<ServiceProvider> providers = loadProfiles();
        providers.add(provider);
        saveProfiles(providers);
        logger.log(Level.INFO, "Added new profile with ID: {0}", provider.getId());
    }

    public ServiceProvider getProfileById(String id) {
        if (id == null || id.trim().isEmpty()) {
            return null;
        }

        return loadProfiles().stream()
                .filter(p -> id.equals(p.getId()))
                .findFirst()
                .orElse(null);
    }

    public List<ServiceProvider> getAllProfiles() {
        return loadProfiles();
    }
}