package
{
  import flash.display.*;
  import flash.text.*;
  import flash.events.*;
 
  public class Conv extends Sprite
  {
    private var mText:TextField;
    function Conv()
    {
      mText = new TextField();
      mText.width = 800;
      mText.height = 600;
 
      addChild(mText);
      mText.type = TextFieldType.INPUT;
      mText.background = true;
      mText.backgroundColor = 0xffffff;
      mText.multiline = true;
 
      var btn:StartButton = new StartButton();
      addChild(btn);
      btn.y = 580;
      btn.buttonMode = true;
      btn.addEventListener(MouseEvent.CLICK, onClick);
 
//      tx.height = 500;
//      removeChild(tx);
//      addChild(tx);
//      tx.y = 340;
//      tx.width = 400;
    }
 
    private function onClick(e:MouseEvent):void
    {
      var s:SVGConverter = new SVGConverter(mText.text);
      var canvas:Sprite = new Sprite();
      addChild(canvas);
      canvas.y = 220;
 
      var gen:KMLGenerator = new KMLGenerator()
      s.renderShapes(gen);
      mText.text = gen.dump();
    }
 
  }
}
 
class SVGConverter
{
  import flash.geom.*;
  import flash.display.*;
 
  private var X:XML;
  private var mShapes:Array = [];
  private var mCurPt:Point;
  function SVGConverter(src:String)
  {
    X = new XML(src);
    var list:XMLList = X.children();
    for each(var ch:XML in list) {
      if (ch.localName() == "path") 
        addPath(ch);
    }
  }
 
  public function renderShapes(g:IGraphics):void
  {
    for each(var sh:SVGShape in mShapes) {
      renderAShape(sh, g);
    }
  }
 
  private function renderAShape(sh:SVGShape, g:IGraphics):void
  {
    g.beginFill(sh.fill);
  //    g.lineStyle(0, 0xffffff);
    for each(var seg:Segment in sh.segments) {
      drawSegment(seg, g);
    }
    g.endFill();
  }
 
  public static function nearZero(v:Number):Boolean
  {
    return (v < 0.1) && (v > -0.1);
  }
 
  private function drawSegment(s:Segment, g:IGraphics):void
  {
    var len:int = s.points.length;
    var pt2:Point;
    var pt3:Point;
 
    for (var i:int = 0;i < len;i++) {
      var pt:Point = s.points[i] as Point;
      if (i == 0) {
        if (mCurPt && nearZero(mCurPt.x - pt.x) && nearZero(mCurPt.y - pt.y)) {
          
        } else {
          g.moveTo(pt.x, pt.y);
          mCurPt = pt;
        }
        continue;
      } 
 
      if (s.curved)
      {
        pt2 = s.points[++i] as Point;
        pt3 = s.points[++i] as Point;
        b3(g, mCurPt.x, mCurPt.y, pt.x, pt.y, pt2.x, pt2.y, pt3.x, pt3.y, 3);
        mCurPt = pt3;
      } else {
        mCurPt = pt;
        g.lineTo(pt.x, pt.y);
      }
    }
  }
 
  private function b3(g:IGraphics, x0:Number,y0:Number,x1:Number,y1:Number,x2:Number,y2:Number,x3:Number,y3:Number,divs:uint = 100):void
  {
      var up:Number = 1.0 / (divs + 1);
      var tm:Number;
      for (var t:Number = 0; t < 1;t += up) {
          tm = 1 - t;
          g.lineTo(
              x0 * Math.pow(tm, 3) + 3 * x1 * t *Math.pow(tm, 2) + 3 * x2 * Math.pow(t, 2) * tm + x3 * Math.pow(t, 3),
              y0 * Math.pow(tm, 3) + 3 * y1 * t *Math.pow(tm, 2) + 3 * y2 * Math.pow(t, 2) * tm + y3 * Math.pow(t, 3)
          );
  
      }
      g.lineTo(x3, y3);
  }
 
 
  private function addPath(x:XML):void
  {
    var d:String = x.@d[0];
    var records:Array = d.split(/ +/);
 
    var op:String = null;
    var index:int = 0;
    var pt:Point = new Point();
    var sh:SVGShape = new SVGShape();
    var seg:Segment;
 
    for each(var r:String in records) {
      var n:Number;
      if (r == '') continue;
 
      if (/[a-zA-Z]/.test(r))
        n = NaN;
      else
        n = parseFloat(r);
 
      if (isNaN(n)) {
        if (seg && (r == 'M' || r == 'Z' || (seg.points.length > 1 &&  ((r == 'L' && seg.curved) || (r == 'C' && !seg.curved))) )) {
          sh.addSegment(seg);
          seg = null;
        }
 
        if (!seg)
          seg = new Segment();
        if (r == 'C')
          seg.curved = true;
 
        if ((r == 'C' || r == 'L') && seg.points.length == 0)
          seg.addPoint(pt);
 
        op = r;
        index = 0;
        continue;
      } else {
        if ((index%2) == 0) {
          pt.x = n;
        }
        else {
          pt.y = n;
          seg.addPoint(pt);
        }
      }
 
      index++;
    }
 
    mShapes.push(sh);
    sh.fill = parseInt(x.@fill[0].substring(1), 16);
//    STDOUT.puts(x.@d[0]);
  }
}
 
class SVGShape
{
  public var segments:Array = [];
  public var fill:uint;
  public function addSegment(s:Segment):void
  {
    segments.push(s);
  }
}
 
class Segment
{
  import flash.geom.*;
  public var curved:Boolean = false;
  public var points:Array = [];
 
  public function addPoint(pt:Point):void
  {
    var pt2:Point = new Point(pt.x, pt.y);
    points.push(pt2);
  }
}
 
class StartButton extends flash.display.Sprite
{
  import flash.display.*;
  import flash.geom.*;
 
  public static const G_COLORS:Array = [0xaaaaaa, 0x555555];
  public static const G_ALPHAS:Array = [1, 1];
  public static const G_RATIOS:Array = [0, 255];
  private var mGradTrans:Matrix;
 
  function StartButton()
  {
    mGradTrans = new Matrix();
    mGradTrans.createGradientBox(30, 30, Math.PI/2);    
 
    var g:Graphics = graphics;
    g.beginGradientFill(GradientType.LINEAR, G_COLORS, G_ALPHAS, G_RATIOS, mGradTrans);
    g.drawRect(0, 0, 40, 20);
    g.endFill();
  }
}
 
class KMLGenerator implements IGraphics
{
  import flash.utils.*;
 
  private var polygons:Array = [];
  private var coords:Array = [];
  private var fills:Dictionary = new Dictionary();
  private var mScale:Number = 0.0007;
  private var mNextStyleId:int = 1;
  private var mCurStyleId:int;
 
  public function dump():String
  {
    var poly_elems:Array = [];
    var len:int = polygons.length;
    poly_elems.push('<?xml version="1.0" encoding="UTF-8"?>\n<kml xmlns="http://www.opengis.net/kml/2.2">\n<Document>');
 
    for (var clr:String in fills) {
      var bgr:uint = parseInt(clr);
      bgr = (bgr&0x00ff00) | ((bgr&0xff0000)>>16) | ((bgr&0xff)<<16);
      var hex:String = ("000000" + bgr.toString(16));
      hex = hex.substring(hex.length - 6);
      poly_elems.push( "<Style id=\"f"+fills[clr]+"\"><PolyStyle><color>ff"+hex+"</color><colorMode>normal</colorMode><outline>0</outline></PolyStyle></Style>" );
    }
 
    for (var i:int = 0;i < len;i++) {
      for each(var ll:LatLng in polygons[i].coords)
        ll.alt = i*100;
      poly_elems.push("<Placemark><styleUrl>#f"+polygons[i].sid+"</styleUrl><Polygon><outerBoundaryIs><LinearRing><coordinates>"+polygons[i].coords.join(' ')+"</coordinates></LinearRing></outerBoundaryIs></Polygon></Placemark>");    
    }
 
    poly_elems.push('</Document></kml>');
 
    return poly_elems.join("\n");
  }
 
  public function beginFill(c:uint):void
  {
    if (fills[c]) {
      mCurStyleId = fills[c] as int;
    } else {
      fills[c] = mNextStyleId++;
      mCurStyleId = fills[c];
    }
 
    coords = [];
  }
 
  public function endFill():void
  {
    if (coords.length > 0) {
      polygons.push({sid: mCurStyleId, coords: coords});
      coords = [];
    }
  }
 
  public function moveTo(x:Number, y:Number):void
  {
    endFill();
    
 
    var ll:LatLng = new LatLng();
    XYtoLatLng(x * mScale, y * mScale + 0.2, ll);
 
    coords.push(ll);
  }
 
  public function lineTo(x:Number, y:Number):void
  {
    var ll:LatLng = new LatLng();
    XYtoLatLng(x * mScale, y * mScale + 0.2, ll);
 
    coords.push(ll);
  }
 
  public static function XYtoLatLng(x:Number, y:Number, out:LatLng):Boolean
  {
    const PI:Number = Math.PI;
    const DPI:Number = PI * 2.0;
    const HPI:Number = PI / 2.0;
 
    var lng:Number = bround((x-0.5) * DPI, -PI, PI);
    
    var g:Number = (y-0.5) * -DPI;
    var lat:Number = 2.0 * Math.atan( Math.exp(g) ) - HPI;
    
    out.lat = lat * 180.0 / PI;
    out.lng = lng * 180.0 / PI;
    return true;
  }
 
  private static function bround(v:Number, min:Number, max:Number):Number
  {
    if (v>max) return max;
    if (v<min) return min;
    return v;
  }
}
 
class LatLng
{
  public var lng:Number, lat:Number, alt:int;
  public function toString():String
  {
    return lng+","+lat+","+alt;
  }
}
 
interface IGraphics
{
  function beginFill(c:uint):void;
  function endFill():void;
  function moveTo(x:Number, y:Number):void;
  function lineTo(x:Number, y:Number):void;
}