// AUTHORED SHIM (not copied). Non-battle game types (settings widgets, error-dialog
// data, login-bonus, deck-builder, story chapter-selection, room-match, socket.io)
// swept into the copy closure but never driven headless. Stubbed in their ORIGINAL
// namespaces so the copied engine resolves their type references. Enums are replicated
// VERBATIM from decomp (integer values can be cast); classes are empty until the loop
// demands a member.
using UnityEngine;

namespace Wizard.Dialog.Setting
{
    // Real base of ItemButton/ItemToggle/... (copied). Abstract methods the copied
    // subclasses override -- without this base they fall back to the unrelated
    // Wizard.Item data class and CS0115 ("no method to override").
    public abstract class Item : MonoBehaviour
    {
        public abstract void AddChangeCallback(EventDelegate.Callback callback);
        public abstract void SetActive_SeparatorLine(bool isActive);
    }
}

namespace Wizard.ErrorDialog
{
    // Real Wizard.ErrorDialog.Data; without it Dialog.cs's unqualified `Data` falls
    // back to the static Wizard.Data god-object (CS0718/0722/0723 + missing ButtonType).
    public class Data
    {
        public enum ContactDisplayType { _NONE_, 表示, MAX }
        public enum ButtonType { _NONE_, OK, リトライ, タイトルへ戻る, ホームへ戻る, アプリ終了, バージョンアップ, 推奨端末一覧, MAX }

        public string TitleId { get; private set; }
        public string BodyId { get; private set; }
        public bool IsDisplayContact { get; private set; }
        public ButtonType MainButton { get; private set; }
        public ButtonType SubButton { get; private set; }
        public int PanelDepth { get; private set; }

        public Data(string id, string titleId, string bodyId, string contactDisplay,
                    string mainButton, string subButton, string panelDepth) { }
    }
}

namespace Wizard.Battle.UI
{
    public enum CantAttackType { Null, All, Class, NotHasGuard, Unit, Max }
}

namespace Wizard.Battle.View
{
    // Decomp bases (dropped by the hand stub): both derive from BattleCardView, which
    // carries the IBattleCardView impl — so they convert to IBattleCardView via it.
    // The decomp ClassBattleCardViewBase also implements IClassBattleCardView; the resolution
    // path casts the created view to it (ClassBattleCardBase.Setup), so re-attach the dropped
    // interface here with no-op members (the leaf PlayerClassBattleCardView inherits them).
    public abstract class ClassBattleCardViewBase : BattleCardView, IClassBattleCardView
    {
        // HEADLESS-FIX (M-HC-4a): forward the BuildInfo to the BattleCardView base so a class (leader)
        // view's CardInfo resolves to its backing card — the receive ATTACK path reads CardInfo.IsClass
        // (true for a leader) via AttackSelectControl.IsCardTranslatable when an attack targets the leader.
        protected ClassBattleCardViewBase() { }
        protected ClassBattleCardViewBase(BuildInfo buildInfo) : base(buildInfo) { }
        public virtual Wizard.Battle.Player.ClassCharacter.IClassCharacter ClassCharacter => null;
        public virtual void StartOutFrame() { }
        public virtual void StartIntoFrame() { }
        public virtual float GetCurrentClipTime() => 0f;
        public virtual bool GetCurrentClipIsName(global::ClassCharaPrm.MotionType motionType) => false;
        public virtual void ClearSpineObject() { }
    }
    public class NullBattleCardView : BattleCardView { public NullBattleCardView() { } public NullBattleCardView(BuildInfo buildInfo) : base(buildInfo) { } public static void ReleaseSharedDummy() { } } // HEADLESS-FIX (M-HC-4a): chain BuildInfo so a null-view card's CardInfo still resolves

    // The decomp NullClassBattleCardView is `: NullBattleCardView, IClassBattleCardView, IBattleCardView`;
    // base-clause recovery kept only the base class. IBattleCardView is satisfied via the BattleCardView
    // base, but IClassBattleCardView was dropped. The generated NullClassBattleCardView stub already
    // provides that interface's members (public no-ops), so just re-attach the dropped interface here.
    // The resolution path's VirtualClone (createNullView) -> ClassBattleCardBase.Setup casts the null
    // view to IClassBattleCardView, which throws InvalidCastException at runtime without this (M3,
    // fixed-damage spell: Skill_damage.TakeDamageSingle clones the leader before applying damage).
    // Compiles fine without it (it's a cast, not a member call), so the M1 loop never surfaced it.
    public partial class NullClassBattleCardView : IClassBattleCardView { }
}

namespace Wizard.Battle.View.Vfx
{
    // Base of the copied PuzzleBattleManager.PuzzleOpeningVfx (ctor + abstract override).
    public abstract partial class OpeningVfx : SequentialVfxPlayer
    {
        protected OpeningVfx(BackGroundBase backGround) { }
        public abstract void RegisterOpeningVfx(ClassBattleCardBase playerClass, ClassBattleCardBase enemyClass);

        public static string OpenningLogStep = "";
        public static VfxBase ShowBattleUIImmediatelyVfx(BattlePlayerBase battlePlayerBase, bool fixDirection = false, bool isNewReplay = false, bool isBanmenkun = false) => NullVfx.GetInstance();

        public class WaitVoiceEndVfx : VfxBase { }
        public class OpeningShowCharacterPanelVfx : SequentialVfxPlayer { }
    }
}

namespace AnimationOrTween
{
    public enum DisableCondition { DisableAfterReverse = -1, DoNotDisable, DisableAfterForward }
    public enum EnableCondition { DoNothing, EnableThenPlay, IgnoreDisabledState }
}

namespace Wizard.UI.LoginBonus
{
    public class ContinuousData { public ContinuousData(LitJson.JsonData jsonData) { } }
    public class NormalData { public NormalData(LitJson.JsonData jsonData) { } }
    public class SpecialData { public SpecialData(LitJson.JsonData jsonData) { } }
    public class FreeCardPackBoxData { public FreeCardPackBoxData(LitJson.JsonData jsonData) { } }
}

namespace DeckBuilder
{
    public partial class GenerateDeckCode { }
    public partial class GetDeckDataFromCode { }
}

namespace Wizard.Story.ChapterSelection.SelectionProcessing.BattleResult
{
    public interface IProcessing
    {
        IProcessing NextProcessing { get; set; }
        void Execute(Parameter param);
    }
    // Parameter is generated full-surface (ctor + props) in Shim/Generated/Parameter__*.g.cs
}

namespace Wizard.RoomMatch
{
    public partial class PlayerControllerForWatching { }  // SEND_PARAMETER enum is in Generated/PlayerControllerForWatching.g.cs
    public partial class RoomRuleSetting { }
}

namespace Cute
{
    public class SceneChangeParameter { public bool KeepAssets; public SceneType BeforeScene; public SceneType NextScene; public string NextState; }
    public class SceneManager
    {
        public SceneChangeParameter SceneChangeParameter = new SceneChangeParameter();
        public void ChangeScene(string next_scene) { }
        public void ChangeScene(string next_scene, string active_state) { }
        public void ChangeScene(SceneType type, string active_state = "") { }
    }
}

namespace Wizard.Story
{
    public enum StoryApiType { None, MainStory, LimitedStory, EventStory }
    public partial class SelectedStoryInfo { }
    public partial class StoryWorldDataManager { }
    public sealed class StoryWorldData { }  // signature-only type pulled by StoryWorldDataManager full-surface (non-battle)
}

namespace Wizard.Title
{
    // ITitleProc impls pulled by full-surface stubs; referenced as signature types only (non-battle).
    public class BattleRecovery { }
    public class ResourceDownloader { }
    public class TemporaryAssetDeleter { }
}

namespace BestHTTP.SocketIO
{
    // BestHTTP SDK types — minimal hand shim (full-surface would pull the whole SocketIO
    // closure). Node-server real-time socket path is Phase-2; these are off the battle path.
    public sealed class Packet { public System.Collections.Generic.List<byte[]> Attachments { get; set; } }
    public delegate void SocketIOCallback(Socket socket, Packet packet, params object[] args);
    public sealed class Socket
    {
        public string Id => "";
        public Socket On(string eventName, SocketIOCallback callback) => this;
        public Socket On(BestHTTP.SocketIO.SocketIOEventTypes type, SocketIOCallback callback) => this;
        public Socket Off(string eventName) => this;
        public Socket Off() => this;
        public Socket Emit(string eventName, params object[] args) => this;
    }
    public class SocketOptions
    {
        public bool AutoConnect { get; set; }
        public Transports.TransportTypes ConnectWith { get; set; }
        public PlatformSupport.Collections.ObjectModel.ObservableDictionary<string, string> AdditionalQueryParams { get; set; }
    }
    public sealed class SocketManager
    {
        public enum States { Initial, Opening, Open, Paused, Pausing, Reconnecting, Closed }
        public SocketManager(System.Uri uri) { }
        public SocketManager(System.Uri uri, SocketOptions options) { }
        public States State => States.Closed;
        public Socket Socket { get; } = new Socket();
        public Socket this[string nsp] => Socket;
        public void Open() { }
        public void Close() { }
        public void SettingRealtimeNetworkAgent(object agent) { }
    }
}

// ---- namespace anchors (referenced via `using`/qualified path; no type used yet) ----
namespace Wizard.Scripts.Network.Task { internal class _ShimAnchor { } }
namespace Wizard.Scripts.Network.Task.Arena { internal class _ShimAnchor { } }
namespace Wizard.Scripts.Network.Task.Arena.TwoPick { internal class _ShimAnchor { } }
namespace BestHTTP.Decompression.Zlib { internal class _ShimAnchor { } }
