Partition.cs

using System;
using System.Collections.Generic;
using System.IO;
using MtkClient.Library.Config;
using MtkClient.Library.Connection;
using MtkClient.Library.Partitions;
using MtkClient.Library.Utils;

namespace MtkClient.Library
{
    public class PartitionManager : LogBase
    {
        private readonly MtkConfig _config;
        public Gpt GptTable { get; set; }
        public Mbr MbrTable { get; set; }
        public Pmt PmtTable { get; set; }
        public Bpi BpiTable { get; set; }

        public PartitionManager(MtkConfig config, LogLevel logLevel = LogLevel.Info)
        {
            InitLogger(logLevel);
            _config = config;
        }

        public bool ParsePartitionTable(byte[] data, string type = "GPT")
        {
            if (data == null || data.Length < 512)
            {
                Error("Insufficient data for partition table");
                return false;
            }

            switch (type.ToUpper())
            {
                case "GPT":
                    return ParseGpt(data);
                case "MBR":
                    return ParseMbr(data);
                case "PMT":
                    return ParsePmt(data);
                case "BPI":
                    return ParseBpi(data);
                default:
                    Error($"Unknown partition type: {type}");
                    return false;
            }
        }

        private bool ParseGpt(byte[] data)
        {
            try
            {
                Func<long, int, byte[]> readFunc = (off, len) =>
                {
                    if (off + len > data.Length) return null;
                    var result = new byte[len];
                    Array.Copy(data, (int)off, result, 0, len);
                    return result;
                };

                GptTable = new Gpt(readFunc, data.Length);
                return GptTable.Partitions.Count > 0;
            }
            catch (Exception ex)
            {
                Error($"GPT parse failed: {ex.Message}");
                return false;
            }
        }

        private bool ParseMbr(byte[] data)
        {
            try
            {
                MbrTable = new Mbr(data, _config.LogLevel);
                return MbrTable.IsValid;
            }
            catch (Exception ex)
            {
                Error($"MBR parse failed: {ex.Message}");
                return false;
            }
        }

        private bool ParsePmt(byte[] data)
        {
            try
            {
                PmtTable = new Pmt(data, _config.LogLevel);
                return PmtTable.Partitions.Count > 0;
            }
            catch (Exception ex)
            {
                Error($"PMT parse failed: {ex.Message}");
                return false;
            }
        }

        private bool ParseBpi(byte[] data)
        {
            try
            {
                BpiTable = new Bpi(data, _config.LogLevel);
                return BpiTable.Partitions.Count > 0;
            }
            catch (Exception ex)
            {
                Error($"BPI parse failed: {ex.Message}");
                return false;
            }
        }

        public GptPartition FindPartition(string name)
        {
            return GptTable?.FindPartition(name);
        }

        public string PrintPartitions()
        {
            if (GptTable != null)
                return GptTable.PrintGpt();
            if (MbrTable != null)
                return MbrTable.PrintMbr();
            return "No partition table loaded";
        }
    }
}