customerdata

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
using TMPro;
using System.Linq;
using Pixelplacement;

public class DrinkData
{
    public int icecubes = 0;
    public Color color;
}

public class Customer : MonoBehaviour
{
    public DrinkData drink;
    public List<Order> potentialOrders;
    public AudioClip screamClip;
    public AudioClip victoryClip;
    public float currentPatience = 0f;
    public float basePatience = 10f;
    public GameObject receiverPrefab;
    public Transform lineForward;
    public NavMeshAgent agent;
    public Vector3 currentPosition;
    public int numberOfPizza = 2;
    public PizzaData pizzaOrder;
    public Transform patienceBar;
    MeshRenderer patienceBarRenderer;
    public Transform exitPosition;
    public NavMeshObstacle obstacle;
    public GameObject ratingPrefab;
    public Transform counterHeight;
    public Animator animator;

    public Transform bodyModels;
    public void InitCustomerData(CustomerData customerData)
    {
        //  print(customerData.basePatience);
        potentialOrders = customerData.potentialOrders;
        basePatience = customerData.basePatience;
    }
    // Start is called before the first frame update
    void Start()
    {
        Transform bodyModel = bodyModels.GetChild(Random.Range(0, bodyModels.childCount));
        bodyModel.gameObject.SetActive(true);
        animator = bodyModel.GetComponent<Animator>();
        counterHeight = GameObject.FindWithTag("CounterHeight").transform;
        obstacle = GetComponent<NavMeshObstacle>();
        exitPosition = GameObject.FindWithTag("ExitPosition").transform;
        patienceBarRenderer = patienceBar.GetComponent<MeshRenderer>();
        patienceBarRenderer.material.EnableKeyword("_EMISSION");
        //basePatience -= UniversalData.gameManager.day * UniversalData.gameManager.patienceDecreaseRate;
        currentPatience = basePatience;
        lineForward = GameObject.FindWithTag("LineForward").transform;
        agent = GetComponent<NavMeshAgent>();
        UniversalData.lineManager.FindPosition(this);
        DecideOrder();
    }

    Dictionary<string, int> AggregateOrder(List<string> order)
    {
        Dictionary<string, int> aggregatedOrder = new Dictionary<string, int>();
        foreach (string topping in order)
        {
            if (aggregatedOrder.ContainsKey(topping))
            {
                aggregatedOrder[topping]++;
            }
            else
            {
                aggregatedOrder[topping] = 1;
            }
        }
        return aggregatedOrder;
    }
    protected bool pathComplete()
    {
        if (Vector3.Distance(agent.destination, agent.transform.position) <= agent.stoppingDistance)
        {
            if (!agent.hasPath || agent.velocity.sqrMagnitude == 0f)
            {
                return true;
            }
        }

        return false;
    }
    public void MoveTo(Vector3 pos)
    {
        reachedDestination = false;
        agent.SetDestination(pos);
        currentPosition = pos;
        fullyInLine = false;
    }

    List<int> Shuffle(List<int> list)
    {
        int listCount = list.Count;
        //print(listCount);
        List<int> newList = new List<int>();
        for (int i = 0; i < listCount; i++)
        {
            int index = Random.Range(0, list.Count);
            newList.Add(list[index]);
            list.RemoveAt(index);
        }
        return newList;
    }

    public DrinkData DecideDrink()
    {
        DrinkData drinkData;
        drinkData = new DrinkData();
        drinkData.icecubes = Random.Range(1, 5);
        drinkData.color = UniversalData.drinkData[Random.Range(0, UniversalData.drinkData.Count)].color;
        return drinkData;
    }
    public void DecideOrder()
    {
        PizzaData order;
        List<Order> orderDistribution = new List<Order>();
        foreach (Order potentialOrder in potentialOrders)
        {
            for (int i = 0; i < potentialOrder.weight; i++)
            {
                orderDistribution.Add(potentialOrder);
            }
        }
        order = ScriptableObject.CreateInstance<PizzaData>();
        Order orderData = orderDistribution[Random.Range(0, orderDistribution.Count)];
        if (orderData.hasCheese)
        {
            order.toppings.Add("Cheese");
        }
        else if (orderData.hasTomato)
        {
            order.toppings.Add("Tomato");
        }
        foreach (IngredientData topping in orderData.toppings)
        {
            order.toppings.Add(topping.name);
        }
        pizzaOrder = order;
        if(orderData.hasDrink)
        {
            drink = DecideDrink();
        }
        else
        {
            drink = null;
        }
    }
    public GameObject currentReceiver;
    IEnumerator Leave()
    {
        print("Leave");
        if (currentReceiver != null)
        {
            Destroy(currentReceiver.transform.gameObject);
        }
        print("leave");
        pizzaOrderBubble.gameObject.SetActive(false);
        drinkBubble.gameObject.SetActive(false);
        expressionBubbleTemplate.SetActive(false);
        MoveTo(exitPosition.position);
        yield return new WaitForSeconds(1f);
        UniversalData.lineManager.Remove(this);
    }

    float CheckSimilarity(List<string> pizzaToppings, List<string> orderToppings)
    {
        int current = 0;
        int total = 0;
        float similarity = 1f;
        foreach (string topping in pizzaToppings)
        {
            print("i: " + topping);
        }
        Dictionary<string, int> aggregatedPizzaData = AggregateOrder(pizzaToppings);
        Dictionary<string, int> aggregatedOrderData = AggregateOrder(orderToppings);
        List<string> keys = new List<string>(aggregatedOrderData.Keys);
        foreach (string key in keys)
        {
            total += aggregatedOrderData[key];
            current += aggregatedOrderData[key];
            int difference = 0;
            if (aggregatedPizzaData.ContainsKey(key))
            {
                difference = Mathf.Abs(aggregatedPizzaData[key] - aggregatedOrderData[key]);
            }
            else
            {
                difference = aggregatedOrderData[key];
            }
            current -= difference;
        }
        if (current < 0)
        {
            current = 0;
        }
        print("total: " + total + "current: " + current);
        similarity = (float)current / (float)total;
        return similarity;
    }
    public float moneyConstant = 2.5f;
    public float repPatienceConstant = 1f;
    public float repSimilarityConstant = 2.5f;

    public Transform pizzaOrderBubble;
    public GameObject drinkExpressionBubbleTemplate;
    public GameObject expressionBubbleTemplate;
    public Transform drinkBubble;

    public void ReceiveDrink(DrinkType drinkType, int cubes)
    {
        float similarity = 0f;
        if (drinkType.color == drink.color)
        {
            similarity = cubes / drink.icecubes;
        }
        drink = null;
        float reputation = 0f;
        float money = similarity * moneyConstant + similarity * moneyConstant * currentPatience / basePatience;
        if (similarity == 0f)
        {
            reputation = -1f;
        }
        else if (similarity < 0.5f)
        {
            reputation = 1f;
        }
        else
        {
            reputation = 0.25f;
        }
        // add money
        UniversalData.playerManager.AddMoney(money);
        UniversalData.playerManager.AddReputation(reputation);
        drinkBubble.gameObject.SetActive(false);
        drink = null;
        CreateExpression(drinkExpressionBubbleTemplate, reputation);
        StartCoroutine(ReceiveItemRoutine());
    }

    void CreateLabels(float money, float reputation)
    {
        var moneyLabel = Instantiate(ratingPrefab);
        moneyLabel.transform.position = transform.position + new Vector3(0f, 1f, -0.3f);
        moneyLabel.transform.Find("Text").GetComponent<TextMeshPro>().text = "+$" + money;
        var repLabel = Instantiate(ratingPrefab);
        repLabel.transform.position = transform.position + new Vector3(0f, 0.8f, -0.3f);
        repLabel.transform.Find("Text").GetComponent<TextMeshPro>().text = "+R" + reputation;
    }

    void CreateExpression(GameObject expression, float reputation)
    {
        expression.gameObject.SetActive(true);
        expression.transform.localScale = Vector3.zero;


        if (reputation < 0f)
        {
            animator.SetTrigger("angry");
            expression.transform.Find("Sprite").GetComponent<SpriteRenderer>().sprite = UniversalData.expressionIcons["angry"];
        }
        else
        {
            UniversalData.soundManager.PlaySound(victoryClip);
            animator.SetTrigger("happy");
            expression.transform.Find("Sprite").GetComponent<SpriteRenderer>().sprite = UniversalData.expressionIcons["happy"];
        }
        Tween.LocalScale(expression.transform, new Vector3(0.08001078f, 0.08001078f, 0.08001078f), 0.3f, 0f, Tween.EaseSpring, Tween.LoopType.None);
    }
    public void ReceiveItem(PizzaData pizzaData)
    {

        float similarity = CheckSimilarity(pizzaData.toppings, new List<string>(pizzaOrder.toppings));

        bool cooked = false;
        if (pizzaData.cookProgress > pizzaOrder.progressNeeded && pizzaData.cookProgress < pizzaOrder.burntProgress)
        {
            cooked = true;
        }

        // similarity
        //
        float money = similarity * moneyConstant + similarity * moneyConstant * currentPatience / basePatience;
        //
        float reputation = 0f;
        if (similarity == 1f && currentPatience / basePatience > 0.7f)
        {
            reputation = 0.5f;
        }
        if (!cooked)
        {
            money = 0f;
            reputation = -1f;
        }
        if (similarity < 0.5f)
        {
            reputation -= 1f;
        }
        // bubble
        pizzaOrderBubble.gameObject.SetActive(false);
        CreateExpression(expressionBubbleTemplate, reputation);

        CreateLabels(money, reputation);
        // add money
        UniversalData.playerManager.AddMoney(money);
        UniversalData.playerManager.AddReputation(reputation);
        pizzaOrder = null;
        StartCoroutine(ReceiveItemRoutine());

    }

    IEnumerator ReceiveItemRoutine()
    {
        yield return new WaitForSeconds(1.5f);
        if (pizzaOrder == null)
        {
            Tween.LocalScale(expressionBubbleTemplate.transform, Vector3.zero, 0.1f, 0f, Tween.EaseLinear, Tween.LoopType.None);
        }
        else
        {
            Tween.LocalScale(drinkExpressionBubbleTemplate.transform, Vector3.zero, 0.1f, 0f, Tween.EaseLinear, Tween.LoopType.None);
        }
        if (pizzaOrder == null && drink == null)
        {
            StartCoroutine(Leave());
        }
    }

    void StatePizza()
    {
        // rename this
        pizzaOrderBubble.gameObject.SetActive(true);
        Transform top = pizzaOrderBubble.Find("Top");
        Dictionary<string, int> aggregatedOrder = AggregateOrder(pizzaOrder.toppings);
        var templatePrefab = pizzaOrderBubble.Find("Template");
        templatePrefab.gameObject.SetActive(false);
        //1.0633
        List<string> keys = new List<string>(aggregatedOrder.Keys);
        int i = 0;
        foreach (string key in keys)
        {
            // get icon
            Sprite newIcon = UniversalData.materialIcons.FirstOrDefault(x => x.name == key);
            int quantity = aggregatedOrder[key];

            var template = Instantiate(templatePrefab, pizzaOrderBubble.transform);
            template.Find("Image").GetComponent<SpriteRenderer>().sprite = newIcon;
            template.Find("Quantity").GetComponent<TextMeshPro>().text = "" + quantity;
            Transform startPos = pizzaOrderBubble.transform.Find("StartPos");
            template.gameObject.SetActive(true);
            template.transform.name = key;
            template.transform.localPosition = new Vector3(-2.942f, startPos.localPosition.y + 1.51f * i, 0f);
            if (i + 1 == keys.Count)
            {
                top.transform.localPosition = new Vector3(-2.942f, template.transform.localPosition.y + 1.0633f, 0f);
            }
            i++;
        }
        pizzaOrderBubble.transform.localScale = new Vector3(0f, 0f, 0f);
        Tween.LocalScale(pizzaOrderBubble.transform, new Vector3(0.08001078f, 0.08001078f, 0.08001078f), 0.1f, 0f, Tween.EaseLinear, Tween.LoopType.None);
    }
    void StateDrink()
    {
        if(drink == null)
        {
            return;
        }
        // rename this
        drinkBubble.gameObject.SetActive(true);
        Transform top = pizzaOrderBubble.Find("Top");
        Dictionary<string, int> aggregatedOrder = AggregateOrder(pizzaOrder.toppings);
        drinkBubble.transform.Find("IceCube").Find("Quantity").GetComponent<TextMeshPro>().text = "" + drink.icecubes;
        drinkBubble.transform.Find("Drink").Find("Fill").GetComponent<SpriteRenderer>().color = drink.color;
        var templatePrefab = pizzaOrderBubble.Find("Template");
        templatePrefab.gameObject.SetActive(false);
        drinkBubble.transform.localScale = new Vector3(0f, 0f, 0f);
        Tween.LocalScale(drinkBubble.transform, new Vector3(0.08001078f, 0.08001078f, 0.08001078f), 0.1f, 0f, Tween.EaseLinear, Tween.LoopType.None);
    }
    void StateOrder()
    {
        patienceBar.gameObject.SetActive(false);
        firstInLine = true;
        var receiver = Instantiate(receiverPrefab);
        receiver.transform.position = new Vector3(transform.position.x, counterHeight.transform.position.y, counterHeight.position.z);
        receiver.GetComponent<Receiver>().customer = this;
        currentReceiver = receiver;
        StatePizza();
        StateDrink();
    }

    bool fullyInLine = false;
    bool reachedDestination = false;
    bool lostPatience = false;
    bool firstInLine = false;
    // Update is called once per frame
    void Update()
    {
        if (agent.enabled)
        {
            animator.SetFloat("speed", agent.velocity.magnitude);
        }


        if (currentPatience <= 0 && !lostPatience)
        {
            lostPatience = true;
            StartCoroutine(Leave());
        }
        if (!reachedDestination && currentPosition != null && currentPosition != Vector3.zero)
        {
            if (pathComplete())
            {
                reachedDestination = true;
            }
        }
        if (reachedDestination)
        {
            transform.localRotation = Quaternion.Slerp(transform.localRotation, Quaternion.LookRotation(lineForward.forward), Time.deltaTime * 5f);
        }
        if (reachedDestination && !fullyInLine && Vector3.Dot(transform.forward, lineForward.forward) >= 0.99f)
        {
            // we've faced the right position
            fullyInLine = true;
            if (UniversalData.lineManager.IsFirstInLine(this))
            {
                StateOrder();
            }
            else
            {
                patienceBar.gameObject.SetActive(true);
            }
        }
        if (fullyInLine && firstInLine)
        {
            if (currentPatience > 0f)
            {
                currentPatience -= Time.deltaTime;
            }
        }

        Color newColor = Color.Lerp(Color.red, Color.green, currentPatience / basePatience);
        //patienceBarRenderer.material.color = newColor;
        patienceBarRenderer.material.color = newColor;
        patienceBarRenderer.material.SetColor("_EmissionColor", newColor);
    }

    private void OnCollisionEnter(Collision collision)
    {
        Rigidbody rb = collision.transform.GetComponent<Rigidbody>();
        if (rb != null && rb.velocity.magnitude > 0.1f)
        {
            UniversalData.soundManager.PlaySound(screamClip);
            UniversalData.playerManager.AddReputation(-10f);
            animator.applyRootMotion = true;
            agent.enabled = false;
            animator.SetTrigger("fallover");
            UniversalData.lineManager.Remove(this);
            Destroy(gameObject, 2f);
        }
    }
}