using EscapeRoomEngine.Engine.Runtime.Modules;
using EscapeRoomEngine.Engine.Runtime.UI;
using Realms;
using UnityEngine;
using Logger = EscapeRoomEngine.Engine.Runtime.Utilities.Logger;
using LogType = EscapeRoomEngine.Engine.Runtime.Utilities.LogType;

namespace EscapeRoomEngine.Engine.Runtime.Measurements
{
    public class PuzzleStorage : MonoBehaviour
    {
        private const int SchemaVersion = 2;
        
        public static PuzzleStorage Instance { get; private set; }

        [SerializeField]
        private string databasePath = "measurements.realm";
        
        private Realm _realm;

        private void OnEnable()
        {
            var config = new RealmConfiguration
            {
                SchemaVersion = SchemaVersion,
                MigrationCallback = (migration, oldSchemaVersion) =>
                {
                    if (oldSchemaVersion < 1)
                    {
                        // migration from version 0 to 1
                        // nothing to do
                    }
                    if (oldSchemaVersion < 2)
                    {
                        // migration from version 1 to 2
                        // nothing to do
                    }
                    
                    Logger.Log($"Migrated database to version {SchemaVersion}", LogType.Measuring);
                }
            };
            _realm = Realm.GetInstance(config.ConfigWithPath(databasePath));
        }

        private void Awake()
        {
            Instance = this;
        }

        private void Start()
        {
            Logger.Log($"Using realm database at {_realm.Config.DatabasePath}", LogType.Measuring);
        }

        private void OnDisable()
        {
            _realm?.Dispose();
        }

        #region Session

        public void EndSession(Session session, float time)
        {
            session.Time = time;
            
            _realm.Write(() => _realm.Add(session));
        }

        #endregion

        #region Puzzles

        private Puzzle New(PuzzleModuleDescription puzzle)
        {
            Puzzle created = null;
            
            _realm.Write(() => created = _realm.Add(new Puzzle(puzzle)));
            
            return created;
        }

        private Puzzle LoadOrNew(PuzzleModuleDescription puzzle) => _realm.Find<Puzzle>(puzzle.Id) ?? New(puzzle);

        public Puzzle Load(PuzzleModuleDescription puzzle) => _realm.Find<Puzzle>(puzzle.Id);
        
        public void Delete(PuzzleModuleDescription puzzle)
        {
            var found = Load(puzzle);
            if (found != null)
            {
                _realm.Write(() => _realm.Remove(found));
            }
        }

        public void EndMeasurement(Session session, PuzzleModuleDescription puzzle, PuzzleMeasurement measurement)
        {
            var found = LoadOrNew(puzzle);
            
            _realm.Write(() =>
            {
                measurement.TimeSolved = Time.time;
                found.Measurements.Add(measurement);
                
                // add solved puzzle to session
                session.PuzzlesSolved.Add(found);
                
                // add plan result to session
                session.PlanResults.Add(new PlanResult(
                    GameControl.Instance.TargetTime,
                    found.Distribution.Cumulative(measurement.Time),
                    GameControl.Instance.EstimatedTime));
            });
        }

        #endregion
    }
}