import React from 'react'

const TwoWaySlab = (props) => {
    var flag=0;
    const choose_positive_min=(value1,value2)=>
    {
      if (value1 >= 0 && value2 >= 0)
      {
        return Math.min(value1, value2);
      }

      else if (value1 >= 0)
      {
        return value1;
      }

      else if (value2 >= 0)
      {
        return value2;
      }

      return -1;
    };

    const find_lowest_nearest_multiple_of_10=(num)=>
    {

      var nearest_multiple;
      nearest_multiple = floor(num/10);
      nearest_multiple=nearest_multiple*10;

      return nearest_multiple;
    };


    const Interpolation=(Assume_tensionsteel,pt_percentage,y)=>
    {
      var len=y.length;
      var ans=y[len-1];
      for (let i = 1; i < len; i++)
      {
        if ((Assume_tensionsteel>=pt_percentage[i-1]) && (Assume_tensionsteel<pt_percentage[i]))
        {
          ans= (((y[i]-y[i-1])/(pt_percentage[i]-pt_percentage[i-1]))*(Assume_tensionsteel-pt_percentage[i-1]))+y[i-1];

          break;
        }
      }

      return ans;
    }

    const Long_Span=props.breadth;
    const Short_Span=props.length;
    const Live_Load=3.5;
    const Dead_Load=0.25;
    const Concrete_grade = 20,Steel_Strength=415;

    const Depth=Short_Span/32;
    const Effective_depth = Math.round(Depth*1000);
    const Total_depth = Effective_depth + 20+4;


    const Self_weight = 25*(1)*(Total_depth/1000)  ;
    const Floor_Finish=1;

    const Total_Load = Live_Load + Dead_Load + Self_weight + Floor_Finish;
    const Factored_Load = 1.5*Total_Load;

    const ratio = Math.float(Long_Span) / Math.float(Short_Span);
    const final_ratio = Math.round(ratio, 2);



    var short_negative_momentcoefficient;
    var short_positive_momentcoefficient;
    var long_negative_momentcoefficient;
    var long_positive_momentcoefficient;


    var Negative_shortspan_Moment = short_negative_momentcoefficient*Factored_Load*(Math.pow(Short_Span,2)) ;

    var Positive_shortspan_Moment = short_positive_momentcoefficient*Factored_Load*(Math.pow(Short_Span,2));

    var Negative_longspan_Moment = long_negative_momentcoefficient*Factored_Load*(Math.pow(Short_Span,2));

    var Positive_longspan_Moment = long_positive_momentcoefficient*Factored_Load*(Math.pow(Short_Span,2));

    var Effective_depth_req = (Math.sqrt((Negative_shortspan_Moment*1000000)/(0.138*Concrete_grade*1000)));


    const pt_percentage=[0.15,0.25,0.5,0.75,1,1.25,1.5,1.75,2,2.25,2.5,2.75,3];
    const y=[0.28,0.36,0.48,0.56,0.62,0.67,0.72,0.75,0.79,0.81,0.82,0.82,0.82];

    const x2 = [300, 275, 250, 225, 200, 175, 150];
    const y2 = [1, 1.05, 1.1, 1.15, 1.2, 1.2, 1,3];




    var Ast_min,Maximum_spacing,a,b,c,root1,root2,discriminant,dia,area_of_bar,no_of_bar,number,spacing,Spacing,Area_requiredx1,Area_providedx,Area_requiredx2,Ast_requiredy1,Area_providedy,Ast_requiredy2,l,v,Tau,pt_in_shorterdirection,y_line ;

    if(Effective_depth_req>Effective_depth)
    {
        Ast_min = (0.0012)*(1000*Total_depth);
        Maximum_spacing = Math.min(3*Effective_depth,300);

        a = (Math.pow((Steel_Strength),2)*0.87)/(Concrete_grade*1000)
        b = -(Steel_Strength*0.87*Effective_depth)
        c = Negative_shortspan_Moment*1000000;

        discriminant = (Math.pow(b,2)) - (4*a*c);

        if (discriminant<0)
        {
          root1=-b/(2*a);
          root2=-b/(2*a);
        }

        else
        {
          root1 = (-b + Math.sqrt(discriminant)) / (2*a);
          root2 = (-b - Math.sqrt(discriminant)) / (2*a);
        }

        Area_requiredx1=choose_positive_min(root1,root2);

        if(Area_requiredx1>=0)
        {

            dia = 8;
            area_of_bar = (3.14*(Math.pow(dia,2)))/4;
            no_of_bar = Area_requiredx1/area_of_bar + 1;
            number = Math.round(no_of_bar);
            spacing = 1000/number;
            Spacing = find_lowest_nearest_multiple_of_10(spacing);

            if (Maximum_spacing>=Spacing)
            {
                Area_providedx = (no_of_bar - 1)*(floor( spacing/ 100) * 100);

                a = (Math.pow((Steel_Strength),2)*0.87)/(Concrete_grade*1000);
                b = -(Steel_Strength*0.87*Effective_depth);
                c = Positive_shortspan_Moment*1000000;

                discriminant = (Math.pow(b,2)) - (4*a*c);

                if (discriminant<0)
                {
                    root1=-b/(2*a);
                    root2=-b/(2*a);
                }

                else
                {
                    root1 = (-b + Math.sqrt(discriminant)) / (2*a);
                    root2 = (-b - Math.sqrt(discriminant)) / (2*a);
                }

                Area_requiredx2=choose_positive_min(root1,root2);

                if (Area_requiredx2>=0)
                {
                    dia=8;
                    area_of_bar = (3.14*(Math.pow(dia,2)))/4;
                    no_of_bar = Area_requiredx2/area_of_bar + 1;
                    number = Math.round(no_of_bar);
                    spacing = 1000/number;
                    Spacing = find_lowest_nearest_multiple_of_10(spacing);

                    if(Maximum_spacing>=Spacing)
                    {
                        a = (Math.pow((Steel_Strength),2)*0.87)/(Concrete_grade*1000);
                        b = -(Steel_Strength*0.87*Effective_depth);
                        c = Negative_longspan_Moment*1000000;

                        discriminant = (Math.pow(b,2)) - (4*a*c);

                        if (discriminant<0)
                        {
                            root1=-b/(2*a);
                            root2=-b/(2*a);
                        }

                        else
                        {
                            root1 = (-b + Math.sqrt(discriminant)) / (2*a);
                            root2 = (-b - Math.sqrt(discriminant)) / (2*a);
                        }

                        Ast_requiredy1=choose_positive_min(root1,root2);
                        if(Ast_requiredy1>=0)
                        {
                            if(Ast_requiredy1>=Ast_min)
                            {
                                dia=8;
                                area_of_bar = (3.14*(Math.pow(dia,2)))/4;
                                no_of_bar = Ast_requiredy1/area_of_bar + 1;
                                number = Math.round(no_of_bar);
                                spacing = 1000/number;
                                Spacing = find_lowest_nearest_multiple_of_10(spacing);

                                if (Maximum_spacing>=Spacing)
                                {
                                    Area_providedy = (no_of_bar - 1)* Math.floor( spacing/ 100) * 100;

                                    a = (Math.pow((Steel_Strength),2)*0.87)/(Concrete_grade*1000);
                                    b = -(Steel_Strength*0.87*Effective_depth);
                                    c =  Positive_longspan_Moment*1000000;

                                    discriminant = (Math.pow(b,2)) - (4*a*c);

                                    if (discriminant<0)
                                    {
                                        root1=-b/(2*a);
                                        root2=-b/(2*a);
                                    }

                                    else
                                    {
                                        root1 = (-b + Math.sqrt(discriminant)) / (2*a);
                                        root2 = (-b - Math.sqrt(discriminant)) / (2*a);
                                    }


                                    Ast_requiredy2 = choose_positive_min(root1, root2);

                                    if (Ast_requiredy2>=0)
                                    {
                                        if (Ast_requiredy2<=Ast_min)
                                        {
                                            dia=8;
                                            area_of_bar = (3.14*(Math.pow(dia,2)))/4;
                                            no_of_bar = Ast_requiredy2/area_of_bar + 1;
                                            number = Math.round(no_of_bar);
                                            spacing = 1000/number;
                                            Spacing = find_lowest_nearest_multiple_of_10(spacing);

                                            if (Maximum_spacing>=Spacing)
                                            {
                                                l = Short_Span+ 0.15;
                                                v = (Total_Load*l)/2;
                                                Tau = (v * 1000) / (1000 * Effective_depth);

                                                pt_in_shorterdirection = (100*Area_requiredx1)/(1000*Effective_depth);



                                                y_line = Interpolation(pt_in_shorterdirection, pt_percentage, y);




                                            }

                                            else
                                            {
                                                alert("Maximum Spacing is less than Spacing for Ast_y2");
                                            }
                                        }
                                        else
                                        {
                                            alert("Ast_requiredy2>Ast_min")
                                        }
                                    }

                                    else
                                    {
                                        alert("Ast_requiredy2 is negative");
                                    }





                                }
                                else
                                {
                                    alert("Maximum Spacing is less than Spacing for Ast_y1");
                                }
                            }
                            else
                            {
                                alert("Ast_requiredy1 < Ast_min")
                            }
                        }
                        else
                        {
                            alert("Required Area y2 is negative");
                        }


                    }
                    else
                    {
                        alert("Maximum Spacing < Spacing for Area_reqx2");
                    }
                }
                else
                {
                    alert("Required Areax2 is negative");

                }

            }
            else
            {
                alert("Maximum Spacing < Spacing for Area_reqx1")
            }


        }
        else
        {
          alert("Required Areax1 is negative");
        }
    }

    else
    {
        alert("The effective depth selected is not sufficient to resist the design ultimate moment")
    }












  return (
    <div>

    </div>
  )
}

export default TwoWaySlab