OnServerShutdown

using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using Oxide.Core;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("ShutdownPlaytimeSaver", "RustPluginGenerator", "1.0.0")]
    [Description("Tracks playtime per player and flushes totals when the server shuts down.")]
    public class ShutdownPlaytimeSaver : RustPlugin
    {
        private const string DataFileName = "Playtime";

        private PluginConfig config;
        private PlaytimeData data;
        private Timer flushTimer;
        private readonly Dictionary<ulong, float> joinTimes = new Dictionary<ulong, float>();

        private class PluginConfig
        {
            [JsonProperty("Auto save interval (seconds)")]
            public float AutoSaveInterval { get; set; } = 300f;

            [JsonProperty("Use hours instead of seconds")]
            public bool UseHours { get; set; } = true;
        }

        private class PlaytimeData
        {
            [JsonProperty("Totals")]
            public Dictionary<ulong, double> Totals { get; set; } = new Dictionary<ulong, double>();

            [JsonProperty("Last shutdown (unix)")]
            public long LastShutdown { get; set; }
        }

        protected override void LoadDefaultConfig() => config = new PluginConfig();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null) throw new Exception();
            }
            catch
            {
                PrintWarning("Configuration file is invalid, using defaults");
                LoadDefaultConfig();
            }
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        private void Init()
        {
            LoadData();
        }

        private void OnServerInitialized()
        {
            if (config.AutoSaveInterval > 0f)
            {
                flushTimer = timer.Every(config.AutoSaveInterval, SaveData);
            }
        }

        private void OnPlayerConnected(BasePlayer player)
        {
            if (player == null) return;
            joinTimes[player.userID.Get()] = Time.realtimeSinceStartup;
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason)
        {
            if (player == null) return;
            Accumulate(player.userID.Get());
        }

        private void OnServerShutdown()
        {
            foreach (var entry in joinTimes)
            {
                Accumulate(entry.Key);
            }
            joinTimes.Clear();
            data.LastShutdown = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
            SaveData();
        }

        private void Accumulate(ulong userId)
        {
            float start;
            if (!joinTimes.TryGetValue(userId, out start)) return;

            double seconds = Time.realtimeSinceStartup - start;
            if (seconds <= 0d) return;

            double existing;
            data.Totals.TryGetValue(userId, out existing);
            data.Totals[userId] = existing + seconds;
            joinTimes[userId] = Time.realtimeSinceStartup;
        }

        private void LoadData()
        {
            data = Interface.Oxide.DataFileSystem.ReadObject<PlaytimeData>(DataFileName) ?? new PlaytimeData();
        }

        private void SaveData()
        {
            if (data == null) return;
            Interface.Oxide.DataFileSystem.WriteObject(DataFileName, data);
        }

        private void Unload()
        {
            if (flushTimer != null)
            {
                flushTimer.Destroy();
                flushTimer = null;
            }
            SaveData();
        }
    }
}