import java.awt.*;
import java.util.*;

//import Point2D;

public class SubdivisionCurve2D extends Curve2D
{
  // Constants
  public final static int APPROXIMATING = 0;
  public final static int INTERPOLATING = 1;


  // Member Variables

  ////////////////////////////////////////////////////////////////////////////
  // CS284:  These are the variable you will be dealing with

  // Also look at the variables in Curve2D.java

  // Array of points on the curve
  Point2D[] m_aCurvePoints = new Point2D[m_iMaxCurvePoints+2];

  // Number of points on the curve
  int m_iCurvePoints = 0;

  // Type of curve, either approximating or interpolating
  int m_iCurveType = APPROXIMATING;

  // Number of levels of subdivision
  int m_iSubdivisionLevel = 0;


  // Add additional varibles here

  //
  ////////////////////////////////////////////////////////////////////////////


  // Member Functions
  public SubdivisionCurve2D(int iLevel, int iType)
  {
    m_iSubdivisionLevel = iLevel;
    m_iCurveType = iType;
  }

  public void setType(int iType)
  {
    m_iCurveType = iType;
    calculateCurve();
  }

  public void setLevel(int iLevel)
  {
    m_iSubdivisionLevel = iLevel;
    calculateCurve();
  }

  public void calculateCurve()
  {
    int i, j;
    Point2D pt;
    pt = new Point2D();
    Point2D pt1, pt2;

    if( m_iCurveType == APPROXIMATING )
      {
	///////////////////////////////////////////////////////////////
	// CS284:  Replace the code below with code to calculate a curve
	//         that approximates the control points (m_aControlPoint[]).
	//         Set m_iCurvePoints to the total number curve points you
	//         are calculating.


	// m_iCurvePoints = m_iSubdivisionLevel * m_iControlPoints * ...
	//num = m_iControlPoints;
	//for (i=0; i<m_iSubdivisionLevel; i++) {
	//	num = 2*num;
	//}

	// make sure m_uiCurvePoints is < m_iMaxCurvePoints
	//if( num <= m_iMaxCurvePoints)
      //{
		// initialize the curve points
		//number of curve points on i-th level
		//m_iCurvePoints = num;
	m_iCurvePoints = m_iControlPoints;
	for (j=0; j<m_iCurvePoints; j++) {
		m_aCurvePoints[j]=(Point2D)(m_aControlPoints[j]).clone();
	}

	// Array of points on the curve, temp
  	Point2D[] m_aCurvePoints_temp = new Point2D[m_iMaxCurvePoints];
		
	for (i=0; i<m_iSubdivisionLevel; i++) {
			
		//make sure m_uiCurvePoints is < m_iMaxCurvePoints
		if( (m_iCurvePoints*2) <= m_iMaxCurvePoints) {
			
			//calculate the curve points for each level
			m_aCurvePoints_temp[0] = (Point2D)(m_aCurvePoints[0]).clone();
			for (j=0; j<m_iCurvePoints-1; j++) {
				pt1 = (Point2D)(m_aCurvePoints[j]).clone();
				pt1.set(pt1.multiply(3.0/4.0));
				pt2 = (Point2D)(m_aCurvePoints[j+1]).clone();
				pt2.set(pt2.multiply(1.0/4.0));
				pt1.set(pt1.add(pt2));
				pt = new Point2D(pt1.getX(), pt1.getY());
				m_aCurvePoints_temp[2*j+1]=pt;
				pt1 = (Point2D)(m_aCurvePoints[j]).clone();
				pt1.set(pt1.multiply(1.0/4.0));
				pt2 = (Point2D)(m_aCurvePoints[j+1]).clone();
				pt2.set(pt2.multiply(3.0/4.0));
				pt1.set(pt1.add(pt2));
				pt = new Point2D(pt1.getX(), pt1.getY());
				m_aCurvePoints_temp[2*j+2]=pt;
			}
			m_aCurvePoints_temp[2*m_iCurvePoints-1] = (Point2D)(m_aCurvePoints[m_iCurvePoints-1]).clone();

			//update the curve points and number of curve points for each level
			m_iCurvePoints = 2*m_iCurvePoints;
			for (j=0; j<m_iCurvePoints; j++) {
				m_aCurvePoints[j] = m_aCurvePoints_temp[j];
			}
		}
      		else {
			System.out.println("Warning: Only " + m_iMaxCurvePoints + " curve points can be calculated");
			break;
      		}
	}
      //}
      //else
      //{
	//	System.out.println("Only " + m_iMaxCurvePoints + " curve points can be calculated");
      //}
	// m_aCurvePoint[0] = m_aControlPoint[0] ...
	// m_aCurvePoint[m_iCurvePoints-1] = ...



	//
	///////////////////////////////////////////////////////////////
      }
    else if( m_iCurveType == INTERPOLATING )
      {
	///////////////////////////////////////////////////////////////
	// CS284:  Replace the code below with code to calculate a curve
	//         that interpolates the control points (m_aControlPoint[]).
	//         Set m_iCurvePoints to the total number curve points you
	//         are calculating.


	// m_iCurvePoints = m_iSubdivisionLevel * m_iControlPoints * ...
	//num = m_iControlPoints;
	//for (i=0; i<m_iSubdivisionLevel; i++) {
	//	num = 2*num - 1;
	//}

	// make sure m_uiCurvePoints is < m_iMaxCurvePoints
	//if( num <= m_iMaxCurvePoints)
      //{
		// initialize the curve points
		//number of curve points on i-th level
		//m_iCurvePoints = num;
	m_iCurvePoints = m_iControlPoints;
	m_aCurvePoints[0]=(Point2D)(m_aControlPoints[0]).clone();
	for (j=0; j<m_iCurvePoints; j++) {
		m_aCurvePoints[j+1]=(Point2D)(m_aControlPoints[j]).clone();
	}
	m_aCurvePoints[m_iCurvePoints+1]=(Point2D)(m_aCurvePoints[m_iCurvePoints]).clone();

	// Array of points on the curve, temp
  	Point2D[] m_aCurvePoints_temp = new Point2D[m_iMaxCurvePoints];
		
	for (i=0; i<m_iSubdivisionLevel; i++) {

		//make sure m_uiCurvePoints is < m_iMaxCurvePoints
		if( (m_iCurvePoints*2-1) <= m_iMaxCurvePoints) {

			//calculate the curve points for each level
			m_aCurvePoints_temp[0] = (Point2D)(m_aCurvePoints[1]).clone();
			for (j=1; j<m_iCurvePoints; j++) {
				pt1 = (Point2D)(m_aCurvePoints[j]).clone();
				pt1.set(pt1.multiply(9.0/16.0));
				pt2 = (Point2D)(m_aCurvePoints[j+1]).clone();
				pt2.set(pt2.multiply(9.0/16.0));
				pt1.set(pt1.add(pt2));
				pt2 = (Point2D)(m_aCurvePoints[j-1]).clone();
				pt2.set(pt2.multiply(-1.0/16.0));
				pt1.set(pt1.add(pt2));
				pt2 = (Point2D)(m_aCurvePoints[j+2]).clone();
				pt2.set(pt2.multiply(-1.0/16.0));
				pt1.set(pt1.add(pt2));
				pt = new Point2D(pt1.getX(), pt1.getY());
				m_aCurvePoints_temp[2*j-1]=pt;
				m_aCurvePoints_temp[2*j]=(Point2D)(m_aCurvePoints[j+1]).clone();
			}

			//update the curve points and number of curve points for each level
			m_iCurvePoints = 2*m_iCurvePoints-1;
			m_aCurvePoints[0] = (Point2D)(m_aCurvePoints_temp[0]).clone();
			for (j=0; j<m_iCurvePoints; j++) {
				m_aCurvePoints[j+1] = (Point2D)(m_aCurvePoints_temp[j]).clone();
			}
			m_aCurvePoints[m_iCurvePoints+1] = (Point2D)(m_aCurvePoints[m_iCurvePoints]).clone();
		}

      		else {
			System.out.println("Warning: Only " + m_iMaxCurvePoints + " curve points can be calculated");
			break;
      		}
      	}	
		//eliminate the first and last repeated curve points
	for (j=0; j<m_iCurvePoints; j++) {
		m_aCurvePoints[j] = m_aCurvePoints[j+1];
	}
      //}
      //else
      //{
	//	System.out.println("Only " + m_iMaxCurvePoints + " curve points can be calculated");
      //}

	// m_aCurvePoint[0] = m_aControlPoint[0] ...
	// m_aCurvePoint[m_iCurvePoints-1] = ...



	//
	///////////////////////////////////////////////////////////////
      }
  }

  public void paint(Graphics g)
  {
    drawControlLines(g);
    //if( m_iCurvePoints <= m_iMaxCurvePoints) {
        drawCurve(g);
        drawControlPoints(g);
    //}
  }

  public void drawCurve(Graphics g)
  {
    if( m_iControlPoints < 2 )
      return;

    int i;
    Point2D pt1, pt2;

    Color c = g.getColor();

    // Lines
    g.setColor(Color.red);
    {
      for( i=0; i < m_iCurvePoints-1; i++ )
	{
	  pt1 = m_aCurvePoints[i];
	  pt2 = m_aCurvePoints[i+1];
	  g.drawLine( pt1.getPixelX(), pt1.getPixelY(),
		      pt2.getPixelX(), pt2.getPixelY() );
	}
    }
    g.setColor(c);

    // Points
    g.setColor(Color.black);
    {
      for( i=0; i < m_iCurvePoints; i++ )
	{
	  pt1 = m_aCurvePoints[i];
	  g.fillOval( pt1.getPixelX()-1, pt1.getPixelY()-1, 3, 3 );
	}
    }
    g.setColor(c);
  }
}