PIbd-23_Nasyrov_A_G_AirplaneWithRadar_hard/src/Generics/AirplaneGenericStorage.java

package src.Generics;

import javax.xml.crypto.dsig.keyinfo.KeyValue;
import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

import src.MovementStrategy.DrawningObjectAirplane;
import src.DrawningObjects.DrawningAirplane;
import src.DrawningObjects.ExtentionDrawningAirplane;
public class AirplaneGenericStorage {
    public final HashMap<String, AirplaneGenericCollection<DrawningAirplane, DrawningObjectAirplane>> _airplaneStorages;
    private static final char _separatorForKeyValue = '|';
    private final char _separatorRecords = ';';
    private static final char _separatorForObject = ':';

    public boolean SaveData(File f) throws IOException {
        if(f.exists()) {
            f.delete();
        }
        f.createNewFile();
        StringBuilder data = new StringBuilder();
        data.append("AirplaneStorage\n");
        for(Map.Entry<String, AirplaneGenericCollection<DrawningAirplane, DrawningObjectAirplane>> record : _airplaneStorages.entrySet()){
            StringBuilder records = new StringBuilder();
            for(DrawningAirplane elem : record.getValue().GetAirplanes())
            {
                records.append(String.format("%s%c", ExtentionDrawningAirplane.GetDataForSave(elem, _separatorForObject), _separatorRecords));
            }
            data.append(String.format("%s%c%s\n", record.getKey(), _separatorForKeyValue, records.toString()));
        }
        if(data.length() == 0)
            return false;
        FileWriter writer = new FileWriter(f);
        writer.write(data.toString());
        writer.flush();
        writer.close();
        return true;
    }
    public boolean LoadData(File f) throws FileNotFoundException {
        if(!f.exists())
            return false;
        StringBuilder bufferTextFromFile =new StringBuilder();
        Scanner s = new Scanner(f);
        while(s.hasNext())
            bufferTextFromFile.append(s.next() + "\n");
        s.close();
        var strs = bufferTextFromFile.toString().split("\n");
        if(strs == null || strs.length == 0)
            return false;
        if (!strs[0].startsWith("AirplaneStorage"))
            return false;
        _airplaneStorages.clear();
        for(String data : strs){
            String st = new String("\\" + Character.toString( _separatorForKeyValue));
            String[]record = data.split(st);
            if (record.length != 2)
                continue;
            AirplaneGenericCollection<DrawningAirplane, DrawningObjectAirplane> collection =
                    new AirplaneGenericCollection<>(_pictureWidth, _pictureHeight);
            String[] set = record[1].split(Character.toString(_separatorRecords));
            for(int i = set.length -1; i >=0; i--){
                String elem = set[i];
                DrawningAirplane airplane = ExtentionDrawningAirplane.CreateDrawningAirplane(elem,
                        _separatorForObject, _pictureWidth, _pictureHeight);
                if (airplane != null)
                {
                    if (!(collection.Insert(airplane)))
                    {
                        return false;
                    }
                }
            }
            _airplaneStorages.put(record[0], collection);
        }
        return true;
    }

    public boolean LoadCollection(File f) throws FileNotFoundException {
        if(!f.exists())
            return false;
        StringBuilder bufferTextFromFile =new StringBuilder();
        Scanner s = new Scanner(f);
        while(s.hasNext())
            bufferTextFromFile.append(s.next() + "\n");
        s.close();
        var strs = bufferTextFromFile.toString().split("\n");
        if(strs == null || strs.length == 0)
            return false;
        if (!strs[0].startsWith("AirplaneCollection"))
            return false;
        String collectionName = strs[1];
        AirplaneGenericCollection<DrawningAirplane, DrawningObjectAirplane> collection = GetCollection(collectionName);
        if(collection == null)
            collection = new AirplaneGenericCollection<>(_pictureWidth, _pictureHeight);
        else
            collection.Clear();
        String[] airplanesInfo = strs[2].split(Character.toString(AirplaneGenericCollection._separatorRecords));
        for(int i = airplanesInfo.length-1; i >= 0; i--){
            String data = airplanesInfo[i];
            DrawningAirplane airplane = ExtentionDrawningAirplane.CreateDrawningAirplane(data,
                    AirplaneGenericCollection._separatorForObject, _pictureWidth, _pictureHeight);
            if (airplane != null)
            {
                if (!(collection.Insert(airplane)))
                {
                    return false;
                }
            }
        }
        AddSetFromFile(collectionName, collection);
        return true;
    }
    public List<String> Keys(){
        if(_airplaneStorages == null)
            return null;
        return _airplaneStorages.keySet().stream().collect(Collectors.toList());
    }
    private final int _pictureWidth;
    private final int _pictureHeight;

    public AirplaneGenericStorage(int pictureWidth, int pictureHeight){
        _airplaneStorages = new HashMap<>();
        _pictureWidth = pictureWidth;
        _pictureHeight = pictureHeight;
    }

    public void AddSet(String name){
        if(_airplaneStorages.containsKey(name))
            return;
        _airplaneStorages.put(name, new AirplaneGenericCollection<>(_pictureWidth, _pictureHeight));
    }

    public void DelSet(String name, AirplaneTrashCollection<DrawningAirplane> trashBox){
        if(!_airplaneStorages.containsKey(name))
            return;
        AirplaneGenericCollection<DrawningAirplane, DrawningObjectAirplane> cur = _airplaneStorages.get(name);
        for(int i = 0; i < cur.Size(); i++)
            trashBox.Push(cur.Get(i));

        _airplaneStorages.remove(name);
    }

    public AirplaneGenericCollection<DrawningAirplane, DrawningObjectAirplane> Get(String name){
        if(!_airplaneStorages.containsKey(name))
            return null;
        return _airplaneStorages.get(name);
    }

    public DrawningAirplane Get(String collectionName, int position){
        return _airplaneStorages.get(collectionName).Get(position);
    }

    public AirplaneGenericCollection<DrawningAirplane, DrawningObjectAirplane> GetCollection(String collectionName){
        return _airplaneStorages.get(collectionName);
    }

    public void AddSetFromFile(String name, AirplaneGenericCollection<DrawningAirplane, DrawningObjectAirplane> toAdd){
        if(_airplaneStorages.containsKey(name)){
            _airplaneStorages.remove(name);
        }
        _airplaneStorages.put(name, toAdd);
    }
}