package com.lemenzo.messenger.retention;

import android.app.job.JobInfo;
import android.app.job.JobScheduler;
import android.content.ComponentName;
import android.content.Context;
import android.content.SharedPreferences;
import android.provider.Telephony;
import android.net.Uri;
import android.util.Log;
import com.lemenzo.messenger.SettingsActivity;
import com.lemenzo.messenger.data.PendingMessageStore;
import java.util.concurrent.TimeUnit;

/** Rolling local SMS/MMS retention. Off is the safe default. */
public final class MessageRetentionManager {
    private static final String TAG="LemenzoMessageRetention";
    private static final int JOB_ID=4901;
    private static final long PERIOD_MS=TimeUnit.HOURS.toMillis(12);
    public static final String OFF="off";
    private MessageRetentionManager(){}

    public static String current(Context context){
        return context.getSharedPreferences(SettingsActivity.PREFS,Context.MODE_PRIVATE)
                .getString(SettingsActivity.PREF_MESSAGE_RETENTION,OFF);
    }

    public static long durationMs(String value){
        if("24h".equals(value))return TimeUnit.HOURS.toMillis(24);
        if("2d".equals(value))return TimeUnit.DAYS.toMillis(2);
        if("4d".equals(value))return TimeUnit.DAYS.toMillis(4);
        if("7d".equals(value))return TimeUnit.DAYS.toMillis(7);
        if("14d".equals(value))return TimeUnit.DAYS.toMillis(14);
        return 0L;
    }

    public static void apply(Context context,String value){
        Context app=context.getApplicationContext();
        if(durationMs(value)<=0){cancel(app);return;}
        schedule(app);
        MessageRetentionJobService.runCleanupAsync(app);
    }

    public static void restore(Context context){
        Context app=context.getApplicationContext();
        if(durationMs(current(app))>0)schedule(app);else cancel(app);
    }

    public static void cleanup(Context context){
        long keep=durationMs(current(context));
        if(keep<=0)return;
        long cutoff=System.currentTimeMillis()-keep;
        try{
            context.getContentResolver().delete(
                    Telephony.Sms.CONTENT_URI,
                    Telephony.Sms.DATE+"<?",
                    new String[]{Long.toString(cutoff)});
            context.getContentResolver().delete(
                    Telephony.Mms.CONTENT_URI,
                    Telephony.Mms.DATE+"<?",
                    new String[]{Long.toString(Math.max(0L,cutoff/1000L))});
            // SMS/MMS provider does not always remove empty thread rows automatically.
            // Explicitly purge obsolete conversations so retention can never leave an
            // empty orphan that later renders as an "Unknown" conversation.
            context.getContentResolver().delete(
                    Uri.parse("content://mms-sms/conversations/obsolete"), null, null);
            new PendingMessageStore(context).removeOlderThan(cutoff);
        }catch(SecurityException e){
            Log.w(TAG,"SMS role/permission unavailable during retention cleanup",e);
        }catch(RuntimeException e){
            Log.w(TAG,"Retention cleanup failed",e);
        }
    }

    private static void schedule(Context context){
        JobScheduler scheduler=context.getSystemService(JobScheduler.class);
        if(scheduler==null)return;
        JobInfo info=new JobInfo.Builder(JOB_ID,new ComponentName(context,MessageRetentionJobService.class))
                .setPeriodic(PERIOD_MS)
                .setPersisted(true)
                .build();
        scheduler.schedule(info);
    }

    private static void cancel(Context context){
        JobScheduler scheduler=context.getSystemService(JobScheduler.class);
        if(scheduler!=null)scheduler.cancel(JOB_ID);
    }
}