using GamificationService.Database.GenericRepository;
using GamificationService.Models.Database;
using Microsoft.EntityFrameworkCore.Storage;

namespace GamificationService.Database.UnitOfWork;

public class UnitOfWork : IUnitOfWork
{
    #region Fields
    private readonly ApplicationContext _context;
    private IDbContextTransaction? _transaction;

    // Repository fields
    private IGenericRepository<Rank>? _rankRepository;
    private IGenericRepository<Skill>? _skillRepository;
    private IGenericRepository<Player>? _playerRepository;
    private IGenericRepository<MissionCategory>? _missionCategoryRepository;
    private IGenericRepository<Mission>? _missionRepository;
    private IGenericRepository<MissionRankRule>? _missionRankRuleRepository;
    private IGenericRepository<MissionSkillReward>? _missionSkillRewardRepository;
    private IGenericRepository<MissionItemReward>? _missionItemRewardRepository;
    private IGenericRepository<RankMissionRule>? _rankMissionRuleRepository;
    private IGenericRepository<RankSkillRule>? _rankSkillRuleRepository;
    private IGenericRepository<PlayerSkill>? _playerSkillRepository;
    private IGenericRepository<PlayerMission>? _playerMissionRepository;
    private IGenericRepository<Dialogue>? _dialogueRepository;
    private IGenericRepository<DialogueMessage>? _dialogueMessageRepository;
    private IGenericRepository<DialogueMessageResponseOption>? _dialogueMessageResponseOptionRepository;
    #endregion

    public UnitOfWork(ApplicationContext context)
    {
        _context = context;
    }

    #region Repositories
    public IGenericRepository<Rank> Ranks =>
        _rankRepository ??= new GenericRepository<Rank>(_context);

    public IGenericRepository<Skill> Skills =>
        _skillRepository ??= new GenericRepository<Skill>(_context);

    public IGenericRepository<Player> Players =>
        _playerRepository ??= new GenericRepository<Player>(_context);

    public IGenericRepository<MissionCategory> MissionCategories =>
        _missionCategoryRepository ??= new GenericRepository<MissionCategory>(_context);

    public IGenericRepository<Mission> Missions =>
        _missionRepository ??= new GenericRepository<Mission>(_context);

    public IGenericRepository<MissionRankRule> MissionRankRules =>
        _missionRankRuleRepository ??= new GenericRepository<MissionRankRule>(_context);

    public IGenericRepository<MissionSkillReward> MissionSkillRewards =>
        _missionSkillRewardRepository ??= new GenericRepository<MissionSkillReward>(_context);

    public IGenericRepository<MissionItemReward> MissionItemRewards =>
        _missionItemRewardRepository ??= new GenericRepository<MissionItemReward>(_context);

    public IGenericRepository<RankMissionRule> RankMissionRules =>
        _rankMissionRuleRepository ??= new GenericRepository<RankMissionRule>(_context);

    public IGenericRepository<RankSkillRule> RankSkillRules =>
        _rankSkillRuleRepository ??= new GenericRepository<RankSkillRule>(_context);

    public IGenericRepository<PlayerSkill> PlayerSkills =>
        _playerSkillRepository ??= new GenericRepository<PlayerSkill>(_context);

    public IGenericRepository<PlayerMission> PlayerMissions =>
        _playerMissionRepository ??= new GenericRepository<PlayerMission>(_context);

    public IGenericRepository<Dialogue> Dialogues =>
        _dialogueRepository ??= new GenericRepository<Dialogue>(_context);

    public IGenericRepository<DialogueMessage> DialogueMessages =>
        _dialogueMessageRepository ??= new GenericRepository<DialogueMessage>(_context);

    public IGenericRepository<DialogueMessageResponseOption> DialogueMessageResponseOptions =>
        _dialogueMessageResponseOptionRepository ??= new GenericRepository<DialogueMessageResponseOption>(_context);
    #endregion

    #region Save Methods
    public bool SaveChanges() => _context.SaveChanges() > 0;

    public async Task<bool> SaveChangesAsync() => (await _context.SaveChangesAsync()) > 0;
    #endregion

    #region Transactions
    public async Task BeginTransactionAsync()
    {
        if (_transaction is not null)
            throw new InvalidOperationException("A transaction has already been started.");

        _transaction = await _context.Database.BeginTransactionAsync();
    }

    public async Task CommitTransactionAsync()
    {
        if (_transaction is null)
            throw new InvalidOperationException("No transactions have been started yet.");

        try
        {
            await _transaction.CommitAsync();
        }
        catch
        {
            await RollbackTransactionAsync();
            throw;
        }
        finally
        {
            await _transaction.DisposeAsync();
            _transaction = null;
        }
    }

    public async Task RollbackTransactionAsync()
    {
        if (_transaction is null)
            return;

        await _transaction.RollbackAsync();
        await _transaction.DisposeAsync();
        _transaction = null;
    }
    #endregion
}