public class IndexedFile
{


    /**
     * Disk on which the file will be written
     */
    private Disk disk;
    /**
     * Record size in characters
     */
    private int recordSize;
    /**
     * Key size in characters
     */
    private int keySize;

    // fields describing data portion of file

    /**
     * sectorSize/recordSize
     */
    private int recordsPerSector;
    /**
     * sector number where data begins
     */
    private int firstAllocated;
    /**
     * sectors originally allocated for data
     */
    private int sectorsAllocated;
    /**
     * sector number where overflow begins
     */
    private int overflowStart;
    /**
     * count of overflow sectors in use
     */
    private int overflowSectors;

    // fields describing index portion of file

    /**
     * sector number where index begins
     */
    private int indexStart;
    /**
     * number of sectors allocated for index
     */
    private int indexSectors;
    /**
     * sector number of root of index
     */
    private int indexRoot;
    /**
     * number of levels of index
     */
    private int indexLevels;

    private IndexFileHelper idxFileHelper;

    /**
     * Getter for property 'disk'.
     *
     * @return Value for property 'disk'.
     */
    public Disk getDisk()
    {
        return disk;
    }

    /**
     * Getter for property 'sectorsAllocated'.
     *
     * @return Value for property 'sectorsAllocated'.
     */
    public int getSectorsAllocated()
    {
        return sectorsAllocated;
    }

    /**
     * Getter for property 'firstAllocated'.
     *
     * @return Value for property 'firstAllocated'.
     */
    public int getFirstAllocated()
    {
        return firstAllocated;
    }

    /**
     * Getter for property 'keySize'.
     *
     * @return Value for property 'keySize'.
     */
    public int getKeySize()
    {
        return keySize;
    }

    /**
     * Getter for property 'indexStart'.
     *
     * @return Value for property 'indexStart'.
     */
    public int getIndexStart()
    {
        return indexStart;
    }

    /**
     * Getter for property 'indexSectors'.
     *
     * @return Value for property 'indexSectors'.
     */
    public int getIndexSectors()
    {
        return indexSectors;
    }

    /**
     * Getter for property 'indexRoot'.
     *
     * @return Value for property 'indexRoot'.
     */
    public int getIndexRoot()
    {
        return indexRoot;
    }

    /**
     * Getter for property 'indexLevels'.
     *
     * @return Value for property 'indexLevels'.
     */
    public int getIndexLevels()
    {
        return indexLevels;
    }


    /**
     * Getter for property 'recordSize'.
     *
     * @return Value for property 'recordSize'.
     */
    public int getRecordSize()
    {
        return recordSize;
    }

    /**
     * Constructor
     *
     * @param disk
     * @param recordSize
     * @param keySize
     * @param firstAllocated
     * @param indexStart
     * @param indexSectors
     * @param indexRoot
     * @param indexLevels
     */
    public IndexedFile(Disk disk, int recordSize, int keySize, int firstAllocated, int indexStart, int indexSectors,
                       int indexRoot, int indexLevels)
    {
        this.disk = disk;
        this.recordSize = recordSize;
        this.keySize = keySize;
        this.firstAllocated = firstAllocated;
        this.indexStart = indexStart;
        this.indexSectors = indexSectors;
        this.indexRoot = indexRoot;
        this.indexLevels = indexLevels;
        this.recordsPerSector = disk.getSectorSize() / recordSize;
        this.sectorsAllocated = indexStart;
        this.overflowStart = indexStart + indexSectors;
        this.overflowSectors = 0;
        this.idxFileHelper = new IndexFileHelper(this);
    }

    /**
     * Inserts record
     *
     * @param record - record
     * @return true if ok
     */
    public boolean insertRecord(char[] record)
    {
        //Search for similar record
        if (findRecord(record))
            return false;

        //Determine place to insert
        char[] key = new char[this.getKeySize()];
        System.arraycopy(record, 0, key, 0, this.getKeySize());
        //Get proper sector
        int sectorToInsert = getSector(String.valueOf(key).trim());
        //Get offset in sector
        int offsetToInsert = idxFileHelper.getFirstEmptyDataRecordOffset(sectorToInsert);
        char[] buffer = new char[disk.getSectorSize()];

        //No place in sector - write to overflow
        if (offsetToInsert < 0)
        {
            //Get last user overflow sector
            int ofSector = overflowStart;
            if (overflowSectors > 0)
                ofSector += overflowSectors - 1;
            else
                overflowSectors++;

            //Find empty place
            offsetToInsert = idxFileHelper.getFirstEmptyDataRecordOffset(ofSector);
            if (offsetToInsert < 0)
            {
                ofSector++;
                offsetToInsert = idxFileHelper.getFirstEmptyDataRecordOffset(ofSector);
            }
            sectorToInsert = ofSector;
        }
        //Read target sector
        disk.readSector(sectorToInsert, buffer);
        //Write data to buffer
        System.arraycopy(record, 0, buffer, offsetToInsert, recordSize);
        //Write sector
        disk.writeSector(sectorToInsert, buffer);

        return true;
    }

    /**
     * Searches record
     *
     * @param record - record to search
     * @return true if found
     */
    public boolean findRecord(char[] record)
    {
        char[] key = new char[keySize];
        System.arraycopy(record, 0, key, 0, keySize);
        int sector = idxFileHelper.findSector(key);
        Record r = idxFileHelper.findRecordInSector(sector, key);
        if (r != null)
        {
            char[] tmp = r.convertToData();
            System.arraycopy(tmp, 0, record, 0, Math.min(record.length, tmp.length));
            return true;
        }
        //No record in data area
        else
        {
            //Search in overflow sectors
            for(int i=overflowStart; i<(overflowStart+overflowSectors); i++)
            {
                r = null;
                r = idxFileHelper.findRecordInSector(i, key);
                if(r!=null)
                {
                    char[] tmp = r.convertToData();
                    System.arraycopy(tmp, 0, record, 0, Math.min(record.length, tmp.length));
                    return true;
                }
            }
        }
        return false;
    }


    /**
     * Returns sector number by key
     *
     * @param key - data key
     * @return sector number
     */
    private int getSector(String key)   // returns sector number indicated by key
    {
        char[] keyArray = new char[this.getKeySize()];
        char[] strArray = key.toCharArray();
        System.arraycopy(strArray, 0, keyArray, 0, Math.min(keyArray.length, strArray.length));
        return idxFileHelper.findSector(keyArray);
    }

    /**
     * String representation of object
     */
    public String toString()
    {
        return "IndexedFile:\n" + "recordSize=" + recordSize + "\nkeySize=" + keySize + "\nrecordsPerSector=" + recordsPerSector + "\nfirstAllocated=" + firstAllocated + "\nsectorsAllocated=" + sectorsAllocated + "\noverflowStart=" + overflowStart + "\noverflowSectors=" + overflowSectors + "\nindexStart=" + indexStart + "\nindexSectors=" + indexSectors + "\nindexRoot=" + indexRoot + "\nindexLevels=" + indexLevels;
    }
}