package art.servers.gost.access.controller;

import art.servers.gost.access.Shared;
import art.servers.gost.access.configuration.ConfigurationDetail_Cleaner;
import java.io.File;
import static java.lang.Thread.sleep;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.attribute.BasicFileAttributes;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;




public class Controller_Cleaner extends Controller
{
    protected String name = null;
    private MyComparator comparator = new MyComparator();
    
    private ConfigurationDetail_Cleaner configuration = null;
    private File path = null;
    private  long free = 0;
    private  long total = 0;    

    
    public Controller_Cleaner(ConfigurationDetail_Cleaner configuration)
    {
        this.name = Shared.getMessage("Controller cleaner");
        this.setName(this.name);
        this.configuration = configuration;
    }

   
    public void run()
    {
        Shared.traceInformation(name, Shared.getMessage("Starting"));

        while (isInterrupted() == false)
        {
            DecimalFormat formato1 = new DecimalFormat("###,###,###");
            
            try
            {
                free = (long)(path.getFreeSpace() / 1073741824L);
                total = (long)(path.getTotalSpace() / 1073741824L);
                
                // Eliminar si se baja por debajo del limite

                String message = Shared.getMessage("Free") + " " +  formato1.format(free) + " " + Shared.getMessage("GB") + ", ";
                message = message + Shared.getMessage("Minimum") + " " +  formato1.format(configuration.minimumFreeSpace) + " " + Shared.getMessage("GB");
                // Shared.println("Cleaner", message);

                List<File> lfile = new ArrayList<File>();
                
                if (free < configuration.minimumFreeSpace)
                {
                    for (String path : configuration.paths)
                    {
                        try
                        {
                            File folder = new File(path);
                            lfile.addAll(Arrays.asList(folder.listFiles()));
                        }
                        catch (Exception e)
                        {
                            // e.printStackTrace();
                        }
                    }
                    
                    delete(lfile);
                    free = (long)(path.getFreeSpace() / 1073741824L);
                    total = (long)(path.getTotalSpace() / 1073741824L);
                    
                    message = Shared.getMessage("Free") + " " +  formato1.format(free) + " " + Shared.getMessage("GB") + ", ";
                    message = message + Shared.getMessage("Minimum") + " " +  formato1.format(configuration.minimumFreeSpace) + " " + Shared.getMessage("GB");
                    // Shared.println("Cleaner", message);
                }
                
            }
            catch (Exception e)
            {
            }
            
            try
            {
                sleep(configuration.polling * 1000);
            } 
            catch (Exception e)
            {
            }
        }
        
        Shared.traceInformation(name, Shared.getMessage("Finishing"));
    }





    private void delete (List<File> lfile)
    {
        Collections.sort(lfile, comparator);

        for (File file : lfile)
        {
            deleteAll(file);
            file.delete();

            long free = (long)(path.getFreeSpace() / 1073741824L);

            if (free > configuration.minimumFreeSpace)
            {
               return;
            }
            
        }
    }
    
    

    private void deleteAll (File file)
    {
        try
        {
            for (File child : file.listFiles())
            {
                if (child.isDirectory() == true)
                {
                    deleteAll(child);
                    file.delete();
                }
                else
                {
                    child.delete();
                }
            }
        }
        catch (Exception e)
        {
        }
        
        file.delete();
    }
    


    
    

    private class MyComparator implements Comparator
    {
        public int compare (Object o1, Object o2)
        {
            try
            {
                File file1 = (File)o1;
                File file2 = (File)o2;

                BasicFileAttributes attr1 = Files.readAttributes(Paths.get(file1.getAbsolutePath()), BasicFileAttributes.class);
                BasicFileAttributes attr2 = Files.readAttributes(Paths.get(file2.getAbsolutePath()), BasicFileAttributes.class);

                long timestamp1 = attr1.creationTime().toMillis();
                long timestamp2 = attr2.creationTime().toMillis();
                
                if (timestamp1 > timestamp2) return 1;
                if (timestamp1 < timestamp2) return -1;
            }
            catch (Exception e)
            {
            }

            return 0;
        }
    }      
    
    
}