clear;
close all;
clc;

try
    % 1. Verileri Yükle
    % ----------------
    % Overall sonuçlarını yükle (Bağımlı değişken Y)
    filename_overall = 'results_YM20_OverallBased.xlsx';
    [num_data, ~, raw_data] = xlsread(filename_overall);
    Y = num_data(1:end-1, :);  % Son satırı çıkar
    
    % Kriter sonuçlarını yükle (Bağımsız değişkenler X)
    filename_criteria = 'results_criteriabasedYM20.xlsx';
    sheet_names = {'Criteria_1', 'Criteria_2', 'Criteria_3', 'Criteria_4'}; 
    num_criteria = length(sheet_names);
    
    % Her kullanıcı için kriter verilerini yükle ve ön işle
    X_users = cell(num_criteria, 1);
    for i = 1:num_criteria
        [num, ~, ~] = xlsread(filename_criteria, sheet_names{i});
        data = num(1:end-1, :);  % Son satırı alma
        
        % Veri ön işleme
        for j = 1:size(data, 2)
            current_col = data(:, j);
            % NaN değerleri temizle
            valid_values = current_col(~isnan(current_col));
            if ~isempty(valid_values)
                % Aykırı değerleri temizle
                q1 = quantile(valid_values, 0.25);
                q3 = quantile(valid_values, 0.75);
                iqr = q3 - q1;
                lower_bound = q1 - 1.5 * iqr;
                upper_bound = q3 + 1.5 * iqr;
                current_col(current_col < lower_bound | current_col > upper_bound) = NaN;
                
                % Min-max normalizasyon
                data(:, j) = (current_col - min(valid_values)) / (max(valid_values) - min(valid_values) + eps);
            end
        end
        
        X_users{i} = data;
        fprintf('Kriter %d veri boyutu: %dx%d\n', i, size(data, 1), size(data, 2));
    end
    
    % Veri boyutlarını yazdır
    fprintf('Overall veri boyutu: %dx%d\n', size(Y, 1), size(Y, 2));
    
    % Geçerli kullanıcı sayısını bul
    num_users = size(Y, 1);
    
    % 2. Her Kullanıcı için Ağırlık Hesapla
    % -----------------------------------
    user_weights = zeros(num_users, num_criteria);
    
    for user = 1:num_users
        % Kullanıcının tüm kriter değerlerini bir matriste topla
        X_user = zeros(size(Y, 2), num_criteria);
        for c = 1:num_criteria
            X_user(:, c) = X_users{c}(user, :)';
        end
        
        % Kullanıcının overall değerleri
        Y_user = Y(user, :)';
        
        % Geçerli verileri bul
        valid_indices = ~isnan(Y_user) & all(~isnan(X_user), 2);
        
        if sum(valid_indices) > 0
            X_valid = X_user(valid_indices, :);
            Y_valid = Y_user(valid_indices);
            
            try
                % Regresyon analizi
                beta = regress(Y_valid, [ones(size(X_valid,1),1) X_valid]);
                
                % Ağırlıkları hesapla
                weights = abs(beta(2:end));
                weights(weights < 0.1) = 0;  % Çok küçük ağırlıkları sıfırla
                if sum(weights) > 0
                    weights = weights / sum(weights);
                else
                    % Kriter performansına dayalı ağırlık
                    criterion_performance = zeros(1, num_criteria);
                    for c = 1:num_criteria
                        criterion_performance(c) = mean(X_users{c}(user, :), 'omitnan');
                    end
                    weights = criterion_performance / (sum(criterion_performance) + eps);
                end
                user_weights(user, :) = weights;
            catch err
                fprintf('Kullanıcı %d için hesaplama hatası:\n%s\n', user, err.message);
                % Kriter performansına dayalı varsayılan ağırlık
                criterion_performance = zeros(1, num_criteria);
                for c = 1:num_criteria
                    criterion_performance(c) = mean(X_users{c}(user, :), 'omitnan');
                end
                user_weights(user, :) = criterion_performance / (sum(criterion_performance) + eps);
            end
        else
            fprintf('Kullanıcı %d için geçerli veri yok\n', user);
            % Eşit ağırlık
            user_weights(user, :) = ones(1, num_criteria) / num_criteria;
        end
    end
    
    % Geçersiz kullanıcıları temizle
    valid_users = any(user_weights ~= 0, 2);
    user_weights = user_weights(valid_users, :);
    valid_user_ids = find(valid_users);
    
  % 3. Aggregate Skorları Hesapla
% ---------------------------
aggregate_scores = zeros(length(valid_user_ids), size(Y,2));
methods = {'DUoR', 'DUoR_new', 'Paiw', 'Mul', 'Aug', 'DUoR_Pr'};
base_metrics = {'Precision', 'Recall', 'F1Score', 'Novelty', 'APLT', 'LTC'};

% Her bir metrik-yöntem kombinasyonu için
col = 1;
for m = 1:length(methods)
    for b = 1:length(base_metrics)
        % Her kullanıcı için
        for i = 1:length(valid_user_ids)
            user = valid_user_ids(i);
            user_weights_current = user_weights(i, :);
            
            % Her kriterden ilgili metrik değerini al ve ağırlıklı toplamı hesapla
            weighted_sum = 0;
            for criterion = 1:num_criteria
                % Metrik indeksini hesapla
                metric_idx = (m-1)*length(base_metrics) + b;
                metric_value = X_users{criterion}(user, metric_idx);
                
                % NaN kontrolü
                if ~isnan(metric_value)
                    weighted_sum = weighted_sum + metric_value * user_weights_current(criterion);
                end
            end
            
            % Ağırlıklı ortalamayı kaydet
            aggregate_scores(i, col) = weighted_sum / 4;  % 4 kritere bölerek ortalama al
        end
        col = col + 1;
    end
end

% Ortalama satırını hesapla
mean_scores = mean(aggregate_scores, 1);

% Ortalama satırını aggregate_scores matrisine ekle
aggregate_scores_with_mean = [aggregate_scores; mean_scores];

% Sonuçları kaydet
metric_names = cell(1, size(aggregate_scores, 2) + 1);
col = 1;
for m = 1:length(methods)
    for b = 1:length(base_metrics)
        metric_names{col} = sprintf('%s_%s', base_metrics{b}, methods{m});
        col = col + 1;
    end
end
metric_names{end} = 'UserID';

% UserID'leri ekle ve ortalama satırı için -1 kullan
scores_with_ids = [aggregate_scores_with_mean [valid_user_ids; -1]];
aggregate_table = array2table(scores_with_ids, 'VariableNames', metric_names);

% Row names ekle
row_names = cell(size(scores_with_ids, 1), 1);
for i = 1:length(valid_user_ids)
    row_names{i} = sprintf('User%d', valid_user_ids(i));
end
row_names{end} = 'Average';
aggregate_table.Properties.RowNames = row_names;

% Tabloyu kaydet
writetable(aggregate_table, 'user_aggregate_scores.xlsx', 'WriteRowNames', true);

    % 4. Sonuçları Kaydet ve Doğrulama Kontrolleri
    % ------------------------------------------
    % Ağırlıklar için tablo oluştur
    weight_names = cell(1, num_criteria + 1);
    for i = 1:num_criteria
        weight_names{i} = sprintf('Weight_C%d', i);
    end
    weight_names{end} = 'UserID';
    
    weights_with_ids = [user_weights valid_user_ids];
    weights_table = array2table(weights_with_ids, 'VariableNames', weight_names);
    writetable(weights_table, 'user_criteria_weights_from_overall.xlsx');
    
    % Aggregate skorlar için tablo oluştur
    metric_names = cell(1, size(Y,2) + 1);
    col = 1;
    for m = 1:length(methods)
        for b = 1:length(base_metrics)
            metric_names{col} = sprintf('%s_%s', base_metrics{b}, methods{m});
            col = col + 1;
        end
    end
    metric_names{end} = 'UserID';
    
    % % Sonuçları kaydet
    % scores_with_ids = [aggregate_scores valid_user_ids];
    % aggregate_table = array2table(scores_with_ids, 'VariableNames', metric_names);
    % writetable(aggregate_table, 'user_aggregate_scores.xlsx');
    
    % Sonuç doğrulama kontrolleri
    fprintf('\nSonuç Doğrulama Kontrolleri:\n');
    fprintf('-------------------------\n');
    
    % Metrik aralıklarını tanımla
    metric_ranges = struct();
    metric_ranges.Precision = [0.2, 0.8];
    metric_ranges.Recall = [0.2, 0.8];
    metric_ranges.F1Score = [0.2, 0.8];
    metric_ranges.Novelty = [0.3, 0.8];
    metric_ranges.APLT = [2, 15];
    metric_ranges.LTC = [0.3, 0.8];
    
    % Her yöntem için kontroller
    for m = 1:length(methods)
        fprintf('\n%s Yöntemi:\n', methods{m});
        for b = 1:length(base_metrics)
            idx = (m-1)*length(base_metrics) + b;
            values = aggregate_scores(:, idx);
            
            % NaN değerleri temizle
            values = values(~isnan(values));
            
            if ~isempty(values)
                range = metric_ranges.(base_metrics{b});
                out_of_range = sum(values < range(1) | values > range(2));
                
                fprintf('%s:\n', base_metrics{b});
                fprintf('  Min: %.4f\n', min(values));
                fprintf('  Max: %.4f\n', max(values));
                fprintf('  Ortalama: %.4f\n', mean(values));
                fprintf('  Medyan: %.4f\n', median(values));
                fprintf('  Std: %.4f\n', std(values));
                fprintf('  Aralık Dışı: %d (%.1f%%)\n', ...
                    out_of_range, (out_of_range/length(values))*100);
            else
                fprintf('%s: Geçerli veri yok\n', base_metrics{b});
            end
        end
    end
    
    fprintf('\nToplam geçerli kullanıcı sayısı: %d\n', sum(valid_users));
    
catch err
    fprintf('Hata oluştu:\n');
    fprintf('%s\n', err.message);
    for k = 1:length(err.stack)
        fprintf('File: %s, Line: %d, Function: %s\n', ...
            err.stack(k).file, err.stack(k).line, err.stack(k).name);
    end
end