C# solution with recursive

 public static void minimumBribes(List<int> q)
    {
        var bribes=0;
        for(int i=q.Count-1;i>=0;i--)
        {
            int counter=0;
            Swap(q,i, ref counter);
            if(counter>2)
            {
                Console.WriteLine("Too chaotic");
                return;
            }
            bribes+=counter;
        }        
        Console.WriteLine(bribes);
    }
    
    public static void Swap(List<int> a, int i,ref int counter)
    {
            if(i>=a.Count)
            return;
            
            if(i==0)
            return;
            
            if(a[i - 1] > a[i])
            {
                var item = a[i];
                a[i] = a[i-1];
                a[i-1] = item;
                counter++;
                
                Swap(a,++i,ref counter);
            }
    }

JavaScript:

function minimumBribes(q) {
    const l = q.length;
    let chaos = false;
    let bribes = 0;
    for(let i = 0; i < l; i++){
        let j = i+1;
        if(q[i] - (i+1) > 2){chaos = true; break;}
        while(j < q[i]+20){
            q[j]<q[i] ? bribes++: 0
            j++;
        }
    }
    console.log(chaos ? "Too chaotic" : bribes)
}

Java

public static void minimumBribes(List<Integer> q) {
        int bribes = 0;
        for(int i = q.size(); i > 0; i--){
            if(i == q.get(i - 1)){
                continue;
            }
            if(i == q.get(i - 2)){
                Collections.swap(q, i - 1, i - 2);
                bribes++;
                continue;
            } 
            if(i == q.get(i - 3)){
                Collections.swap(q, i - 3, i - 2);
                Collections.swap(q, i - 2, i - 1);
                bribes += 2;
                continue;
            } 
            System.out.println("Too chaotic");
            return;
        }
        
        System.out.println(bribes);  
    }

So for anyone stuck on the test case with a test case of [1,2,5,3,7,8,6,4]

1. [1,2,3,4,5,6,7,8] => 0 bribes
2. [1,2,5,3,4,6,7,8] => 2 bribes (5 advances by 2)
3. [1,2,5,3,7,4,6,8] => 4 bribes (7 advances by 2)
4. [1,2,5,3,7,8,4,6] => 6 bribes (8 advances by 2)
5. [1,2,5,3,7,8,6,4] => 7 bribes (6 advances by 1) total bribes = 7

This works (y).

public static void minimumBribes(List q) { var arr = q.ToArray(); int totalpositionMoved = 0; bool isChaotic = false; //

        Dictionary<int, int> map = new Dictionary<int, int>();
        for (int i = 0; i < q.Count; i++)
        {
            map.Add(q[i], i);
        }
        //


        for (int sticker = arr.Length ; sticker > 0; sticker --)
        {
            int currentposition = map[sticker];

            if (currentposition < 0)
            {
                break;
            }
            int actualPosition = sticker - 1;
            if (currentposition == actualPosition)
            {
                continue;
            }
            int noOfPositionBribed = actualPosition - currentposition;
            if (noOfPositionBribed > 2)
            {
                isChaotic = true;
                break;
            }
            else if (noOfPositionBribed > 0 && noOfPositionBribed <= 2)
            {
                totalpositionMoved += noOfPositionBribed;
                for(int j=currentposition;j<actualPosition;j++)
                {
                    int temp = arr[j];
                    int temp2 = arr[j+1];

                    int tempkeyval = map[temp];

                    arr[j] = temp2;
                    map[temp] = map[temp2];

                    arr[j+1] = temp;
                    map[temp2] = tempkeyval;


                }
                continue;
            }
        }
        if (isChaotic)
        {
            Console.WriteLine("Too chaotic");
        }
        else
        {
            Console.WriteLine(totalpositionMoved);
        }

    }