MainLogic

using UnityEngine;
using UnityEngine.UI;
using TouchScript.Gestures;
using System.Collections;
using System.Collections.Generic;
using PathCreation;
using TMPro;

public class FishSpawner : MonoBehaviour
{
    public SaveLoadSettings saveLoadSettings;
    private int _mode;
    private int timer;

    public GameObject fishPrefab;
    public Camera mainRaycastCamera;
    public GameObject submarine;
    public GameObject entireSubmarine;
    public PathCreator pathCreator;
    public ParticleSystem hitParticles;
    public ParticleSystem deathParticles;
    public ParticleSystem biteParticles;

    public AudioSource hitSound;
    public AudioSource deathSound;
    public AudioSource biteSound1;
    public AudioSource biteSound2;
    public AudioSource startMusic;
    public AudioSource gameMusic;
    public float spawnDistance = 10f;
    public int maxFishCount = 8;
    public float swimSpeed = 2f;
    public float spawnInterval = 2.5f;
    public float minDistanceBetweenFish = 2f;
    public int maxSpawnAttempts = 10;
    public float speed = 5;

    private List<Fish> activeFish = new List<Fish>();
    private float distanceTravelled;
    public Camera startCamera;
    public Camera gameCamera;
    private bool isGameStarted = false;
    public Canvas menu;
    
    // New variables for timer
    public Canvas gameCanvas;
    public TextMeshProUGUI timerText;
    private float currentTime;

    void Start()
    {
        Debug.Log("FishSpawner Start method called");
        if (startCamera != null) startCamera.gameObject.SetActive(true);
        else Debug.LogError("Start camera is not assigned");
        
        if (gameCamera != null) gameCamera.gameObject.SetActive(false);
        else Debug.LogError("Game camera is not assigned");
        
        if (startMusic != null) startMusic.Play();
        else Debug.LogError("Start music is not assigned");

        saveLoadSettings.LoadData();

        _mode = saveLoadSettings.getDataIntById(0);
        if (_mode == 160) {
            timer = 160;
        } else if (_mode == 300) {
            timer = 300;
        } else if (_mode == 600) {
            timer = 600;
        }
        currentTime = timer;

        Debug.Log($"Mode: {_mode}, Timer set to: {timer} seconds");
        
        if (timerText != null)
        {
            timerText.text = FormatTime(currentTime);
        }
        else
        {
            Debug.LogError("Timer Text is not assigned");
        }
        
        if (gameCanvas != null)
        {
            gameCanvas.gameObject.SetActive(false);
        }
        else
        {
            Debug.LogError("Game Canvas is not assigned");
        }

        if (menu == null)
        {
            Debug.LogError("Menu Canvas is not assigned");
        }

        
    }



    void RemoveUnwantedMeshColliders()
    {
        MeshCollider[] allMeshColliders = FindObjectsOfType<MeshCollider>();
        foreach (MeshCollider collider in allMeshColliders)
        {
            if (!IsPartOfImportantObject(collider.gameObject))
            {
                Destroy(collider);
            }
        }
    }

    bool IsPartOfImportantObject(GameObject obj)
    {
        if (obj == submarine || obj == entireSubmarine || 
            (submarine != null && obj.transform.IsChildOf(submarine.transform)) ||
            (entireSubmarine != null && obj.transform.IsChildOf(entireSubmarine.transform)) ||
            obj.CompareTag("Wall"))
        {
            return true;
        }

        foreach (Fish fish in activeFish)
        {
            if (fish != null && (obj == fish.gameObject || obj.transform.IsChildOf(fish.transform)))
            {
                return true;
            }
        }

        return false;
    }

    public void StartGame()
    {
        Debug.Log("StartGame method called");
        if (!isGameStarted)
        {
            isGameStarted = true;
            Debug.Log("Game started: " + isGameStarted);
            SwitchToGameCamera();
            RemoveUnwantedMeshColliders();
            StartCoroutine(SpawnFishRoutine());
            if (menu != null)
            {
                menu.gameObject.SetActive(false);
                Debug.Log("Menu deactivated");
            }
            if (startMusic != null)
            {
                startMusic.Stop();
                Debug.Log("Start music stopped");
            }
            if (gameMusic != null)
            {
                gameMusic.Play();
                Debug.Log("Game music started");
            }
            if (gameCanvas != null)
            {
                gameCanvas.gameObject.SetActive(true);
                Debug.Log("Game canvas activated");
            }
            currentTime = timer;
            Debug.Log("Timer reset to: " + currentTime);
        }
        else
        {
            Debug.LogWarning("Attempted to start the game, but it's already running");
        }
    }

    void SwitchToGameCamera()
    {
        Debug.Log("Switching to game camera");
        if (startCamera != null)
        {
            startCamera.gameObject.SetActive(false);
            Debug.Log("Start camera deactivated");
        }
        if (gameCamera != null)
        {
            gameCamera.gameObject.SetActive(true);
            Debug.Log("Game camera activated");
        }
    }

    void Update()
    {
        if (!isGameStarted) return;

        distanceTravelled += speed * Time.deltaTime;
        entireSubmarine.transform.position = pathCreator.path.GetPointAtDistance(distanceTravelled);
        entireSubmarine.transform.rotation = pathCreator.path.GetRotationAtDistance(distanceTravelled);

        foreach (Fish fish in activeFish)
        {
            if (fish != null)
            {
                fish.UpdateTargetPosition(submarine.transform.position);
            }
        }

        // Update timer
        currentTime -= Time.deltaTime;
        if (timerText != null)
        {
            timerText.text = FormatTime(currentTime);
        }

        // Check if timer has reached zero
        if (currentTime <= 0)
        {
            Debug.Log("Timer reached zero, ending game");
            EndGame();
        }
    }

    void EndGame()
    {
        isGameStarted = false;
        if (gameMusic != null) gameMusic.Stop();
        if (startMusic != null) startMusic.Play();
        if (gameCanvas != null) gameCanvas.gameObject.SetActive(false);
        if (menu != null) menu.gameObject.SetActive(true);
        SwitchToStartCamera();
        ClearActiveFish();
        ResetGame();
    }

    void SwitchToStartCamera()
    {
        if (startCamera != null) startCamera.gameObject.SetActive(true);
        if (gameCamera != null) gameCamera.gameObject.SetActive(false);
    }

    void ClearActiveFish()
    {
        foreach (Fish fish in activeFish)
        {
            if (fish != null)
            {
                Destroy(fish.gameObject);
            }
        }
        activeFish.Clear();
    }

    void ResetGame()
    {
        distanceTravelled = 0;
        currentTime = timer;
        if (timerText != null)
        {
            timerText.text = FormatTime(currentTime);
        }
    }

    string FormatTime(float timeInSeconds)
    {
        int minutes = Mathf.FloorToInt(timeInSeconds / 60);
        int seconds = Mathf.FloorToInt(timeInSeconds % 60);
        return string.Format("{0:00}:{1:00}", minutes, seconds);
    }

    IEnumerator SpawnFishRoutine()
    {
        while (isGameStarted)
        {
            if (activeFish.Count < maxFishCount)
            {
                SpawnFish();
                yield return new WaitForSeconds(spawnInterval);
            }
            else
            {
                yield return new WaitForSeconds(1f);
            }
        }
    }
    void SpawnFish()
    {
        Vector3 spawnPosition = GetValidSpawnPosition();
        if (spawnPosition != Vector3.zero)
        {
            GameObject fishObject = Instantiate(fishPrefab, spawnPosition, Quaternion.identity, transform);
            Fish fishScript = fishObject.GetComponent<Fish>();
            if (fishScript == null)
            {
                fishScript = fishObject.AddComponent<Fish>();
            }
            fishScript.Initialize(mainRaycastCamera, submarine.transform.position, swimSpeed, biteSound1, biteSound2, biteParticles, this);

            // Ensure the fish has a collider for TouchScript
            Collider fishCollider = fishObject.GetComponent<Collider>();
            if (fishCollider == null)
            {
                fishObject.AddComponent<BoxCollider>();
            }

            activeFish.Add(fishScript);
        }
        else
        {
            Debug.LogWarning("Could not find a valid spawn position for fish.");
        }
    }

        public void OnFishTapped(Fish fish) 
    {
        if (fish != null && activeFish.Contains(fish) && !fish.IsBeingRemoved)
        {
            ParticleSystem particles = Instantiate(hitParticles, fish.transform.position + new Vector3(0, 0, -1f), Quaternion.identity, entireSubmarine.transform);
            particles.Play();
            Destroy(particles.gameObject, particles.main.duration);

            AudioSource hitSoundInstance = Instantiate(hitSound, fish.transform.position, Quaternion.identity, entireSubmarine.transform);
            hitSoundInstance.pitch = Random.Range(0.8f, 1.2f);
            hitSoundInstance.Play();
            Destroy(hitSoundInstance.gameObject, hitSoundInstance.clip.length);

            StartCoroutine(RemoveFishWithAnimation(fish));
        }
    }

    Vector3 GetValidSpawnPosition()
    {
        for (int i = 0; i < maxSpawnAttempts; i++)
        {
            Vector3 candidatePosition = GetSpawnPosition();
            if (IsPositionValid(candidatePosition))
            {
                return candidatePosition;
            }
        }
        return Vector3.zero;
    }

    Vector3 GetSpawnPosition()
    {
        Vector3 randomDirection = Random.insideUnitSphere;
        randomDirection.x = -Mathf.Abs(randomDirection.x);

        Vector3 spawnPosition = submarine.transform.position;
        spawnPosition += submarine.transform.rotation * (randomDirection * spawnDistance);

        return spawnPosition;
    }

    bool IsPositionValid(Vector3 position)
    {
        foreach (Fish fish in activeFish)
        {
            if (fish != null && Vector3.Distance(fish.transform.position, position) < minDistanceBetweenFish)
            {
                return false;
            }
        }
        return true;
    }

    IEnumerator RemoveFishWithAnimation(Fish fish)
    {
        if (fish == null || !activeFish.Contains(fish))
        {
            yield break;
        }

        fish.IsBeingRemoved = true;
        fish.PlayDeathAnimation();

        yield return new WaitForSeconds(1f);

        if (fish != null && activeFish.Contains(fish))
        {
            activeFish.Remove(fish);
            Destroy(fish.gameObject);
            ParticleSystem particles = Instantiate(deathParticles, fish.transform.position, Quaternion.identity);
            particles.Play();
            Destroy(particles.gameObject, particles.main.duration);
            AudioSource deathSoundInstance = Instantiate(deathSound, fish.transform.position, Quaternion.identity);
            deathSoundInstance.pitch = Random.Range(0.8f, 1.2f);
            deathSoundInstance.Play();
            Destroy(deathSoundInstance.gameObject, deathSoundInstance.clip.length);
        }
    }
}