import { _switch } from "@gxc-solutions/lett-js";
import {
  ColorType,
  FillType,
  GradientType,
  IBaseFill,
  IColor,
  IEllipseModel,
  IImageModel,
  IModel,
  IRectangle,
  IRectangleModel,
  IRgbColor,
  ISolidFill,
  IStroke,
  ITransform,
  TypeOfModel,
} from "./interfaces";
import { EllipseObject } from "./models/objects/ellipce";
import { ImageItem } from "./models/objects/image";
import { Stroke } from "./models/stroke";
import { SolidFill } from "./models/solid-fill";
import { Ellipse, Rectangle, Transform } from "@gxc-solutions/math";
import { RectangleItem } from "./models/objects/rectangle";
import { RgbColor } from "@gxc-solutions/colors";

export class Parser {
  constructor() {}

  parse() {}

  parseModel(objects: IModel[]) {
    return objects.map((object) =>
      _switch<TypeOfModel, EllipseObject | ImageItem | RectangleItem>(object.type)
        .case("ellipse-model", () => {
          const ellipseObj = object as IEllipseModel;
          const ellipse = new EllipseObject(ellipseObj.id);

          ellipse.ellipse = new Ellipse(ellipseObj.ellipse.center, ellipseObj.ellipse.radiusX, ellipseObj.ellipse.radiusY);
          ellipse.blendMode = ellipseObj.blendMode;
          ellipse.opacity = ellipseObj.opacity;
          ellipse.stroke = this.parseStroke(ellipseObj.stroke);
          ellipse.fill = this.parseFill(ellipseObj.fill);
          ellipse.transform = this.parseTransform(ellipseObj.transform);
          return ellipse;
        })
        .case("image-model", () => {
          const imageObj = object as IImageModel;
          const image = new ImageItem(imageObj.id);

          image.rectangle = this.parseRectangle(imageObj.rectangle);
          image.blendMode = imageObj.blendMode;
          image.opacity = imageObj.opacity;
          image.stroke = this.parseStroke(imageObj.stroke);
          image.fill = this.parseFill(imageObj.fill);
          image.transform = this.parseTransform(imageObj.transform);
          image.image = {
            isLoading: true,
            image: null,
            url: imageObj.url,
          };
          return image;
        })
        .case("rectangle-model", () => {
          const rectangleObj = object as IRectangleModel;
          const rectangle = new RectangleItem(rectangleObj.id);

          rectangle.rectangle = this.parseRectangle(rectangleObj.rectangle);
          rectangle.blendMode = rectangleObj.blendMode;
          rectangle.opacity = rectangleObj.opacity;
          rectangle.stroke = this.parseStroke(rectangleObj.stroke);
          rectangle.fill = this.parseFill(rectangleObj.fill);
          rectangle.transform = this.parseTransform(rectangleObj.transform);
          return rectangle;
        })
        .result(),
    );
  }

  parseStroke(strokeObj: IStroke) {
    const color = this.parseColor(strokeObj.color);
    return new Stroke(strokeObj.width, color, strokeObj.dash);
  }

  parseFill(fillObj: IBaseFill) {
    return _switch<GradientType | FillType, SolidFill>(fillObj.type)
      .case("solid", () => {
        const solidFillObj = fillObj as ISolidFill;
        const color = this.parseColor(solidFillObj.color);
        return new SolidFill(color);
      })
      .result();
  }

  parseColor(colorObj: IColor) {
    return _switch<ColorType, RgbColor>(colorObj.type)
      .case("rgb", () => {
        const { a, b, g, r } = colorObj as IRgbColor;
        return new RgbColor(r, g, b, a);
      })
      .result();
  }

  parseTransform(transformObj: ITransform) {
    const transform = new Transform();
    transform.rotate = transformObj.rotate;
    transform.scaleX = transformObj.scaleX;
    transform.scaleY = transformObj.scaleY;
    transform.skewX = transformObj.skewX;
    transform.skewY = transformObj.skewY;
    transform.translateX = transformObj.translateX;
    transform.translateY = transformObj.translateY;
    return transform;
  }

  parseRectangle(rectangleObj: IRectangle) {
    return new Rectangle(rectangleObj.top, rectangleObj.left, rectangleObj.width, rectangleObj.height);
  }
}