import { Portfolio } from './model/portfolio';
import { Text } from './framework/primitives/implementations/text';
import { Image } from './framework/primitives/implementations/image';
import { Video } from './framework/primitives/implementations/video';
import { Anchor } from './framework/primitives/implementations/anchor';

import { last } from './framework/helper/last';

import me from './static/media/me.jpg';
import forexMP4 from './static/media/forex.mp4';
import forexWEBM from './static/media/forex.webm';
import adAstraMP4 from './static/media/ad_astra_720.mp4';
import adAstraWEBM from './static/media/ad_astra_720.webm';
import ad_astra_index from './static/media/ad_astra.jpg';
import myNotes from './static/media/my-notes.png';
import processSimulator from './static/media/process-simulator.jpg';
import processSimulatorInput from './static/media/process-simulator-input.jpg';
import citySimulation from './static/media/simulation.jpg';
import color from './static/media/color.jpg';
import platform from './static/media/platform.png';
import photos from './static/media/photos.jpg';
import led from './static/media/led.jpg';
import cvHungarian from './static/cv/schmelczer_andras_cv.pdf';
import cvEnglish from './static/cv/andras_schmelczer_cv.pdf';
import ledMP4 from './static/media/led.mp4';
import ledWEBM from './static/media/led.webm';

export const portfolio: Portfolio = {
  header: {
    name: `András Schmelczer`,
    picture: new Image(me, `a picture of me`),
    about: [
      new Text(
        `I have always been fascinated by the engineering feats that surround us. 
         When I realized that someday I might be able to contribute to these achievements, 
         I knew that is what I need to aim for. As I am starting my sixth semester at the 
         Budapest University of Technology and Economics, I feel I am getting closer to it every day.`
      ),
      new Text(
        `You can see some of the more interesting projects I have worked on below.`
      ),
    ],
  },
  timeline: {
    showMoreText: `Show details`,
    showLessText: `Show less`,
    elements: [
      {
        title: `Video game on an ATtiny85`,
        date: `2020 Spring`,
        figure: new Video(
          last(ad_astra_index.images).path,
          adAstraMP4,
          adAstraWEBM,
          `controls playsinline preload="none"`
        ),
        description: new Text(
          `A simple game engine with a sample game set in space. The greatest challenge was to overcome
          the very limited resources of the hardware, this was also the most rewarding part.`
        ),
        more: [
          new Text(
            `For reducing complexity while maintaining performance a balance had to be found between object-oriented
              and structural programming. For example, a simple prototype-based inheritance is used for the game objects. 
              An optimized SIMD utilizing low level driver is used for drawing on the display. 
              I think the code base is quite readable and at the same time the 
              maximum frame times are between 15ms and 20ms at 8MHz.`
          ),
          new Text(
            `As for the hardware, it is rather simple. Aside from the ATtiny85V, a D096-12864-SPI7 display is used for
            output and a TSOP4838 for input. The circuit runs on 3.3V, so a regulator is also needed. It uses a current
            of 8mA to 11mA on full brightness and around 1.5mA on standby mode.`
          ),
          new Text(
            `There is also fault-tolerant persistent data storage using the built-in EEPROM. 
            For creating sprites (which are also stored in EEPROM) I made a tool to convert PNG-s into C code. 
            This can also be found on GitHub as well as the entire project.`
          ),
          new Anchor(
            `https://github.com/schmelczerandras/ad_astra`,
            `View it on GitHub`
          ),
        ],
      },
      {
        title: `Predicting foreign exchange rates`,
        date: `2019 Autumn`,
        figure: new Video(
          null,
          forexMP4,
          forexWEBM,
          `autoplay loop muted playsinline controls`
        ),
        description: new Text(
          `From the animation we can see that my algorithm does a somewhat acceptable job at
          predicting (blue graph) the EUR/USD rates (green graph).`
        ),
        more: [
          new Text(
            `In a nutshell, the algorithm (written with Python - NumPy, SciPy, Flask), 
            extrapolates in the frequency domain. The steps are the following: smoothing the input values, 
            differentiating, applying a short-time Fourier-transformation with overlapped (and Hanning-windowed) windows,
            extrapolating and then applying the inverse of these transformations to the extrapolated values.`
          ),
          new Text(
            `Of course, there is still plenty of room for improvement, but even with this simple algorithm
            a mostly profitable trading strategy is viable. In my free time I may put more work into it.`
          ),
        ],
      },
      {
        date: `2019 November`,
        title: `My Notes`,
        figure: new Image(myNotes, `two screenshots of the application`),
        description: new Text(
          `A minimalist note organizer and editor powered by Markwon.`
        ),
        more: [
          new Text(
            `A basic android app for creating and filtering notes written in markdown.`
          ),
          new Anchor(
            `https://github.com/schmelczerandras/my-notes`,
            `MyNotes on GitHub`
          ),
          new Text(
            `It was my homework for BME's Android and web development course.
            It was also my first experience with Android development.`
          ),
        ],
      },
      {
        date: `2018 October - November`,
        title: `Simulating the cooling system of a nuclear facility`,
        figure: new Image(processSimulator, `a screenshot of the simulator`),
        description: new Text(
          `Dynamically calculating the temperatures and flow velocities
          in a fluid based cooling system based on a simple model.`
        ),
        more: [
          new Text(
            `A simulated system can contain reactors (heaters / coolers), pumps, heat exchangers,
            drains sources, and of course, pipes.`
          ),
          new Text(
            `The algorithm takes advantages of graphs and matrices to get to a next time frame.`
          ),
          new Text(
            `Python is used for the backend along with Flask and NumPy. A REST API facilitates 
             the communication between the layers. For drawing the frontend HTML5 canvas is utilized.`
          ),
        ],
      },
      {
        date: `2018 October - November`,
        title: `Graph editing application`,
        figure: new Image(
          processSimulatorInput,
          `a picture of the simulator's UI`
        ),
        description: new Text(
          `An intuitive editor to create and edit input files for the nuclear facility simulator.`
        ),
        more: [
          new Text(
            `Nodes can be moved with drag&drop gestures. Editing the parameters of elements 
            can be done on the right panel.`
          ),
          new Text(
            `The UI is built with JavaFX. The output can be exported as JSON or 
            directly uploaded to the simulation backend.`
          ),
        ],
      },
      {
        date: `2018 July - August`,
        title: `City simulation`,
        figure: new Image(citySimulation, `a picture of a low-poly city`),
        description: new Text(
          `Simulating a city where car crashes are more frequent than usual.`
        ),
        more: [
          new Text(
            `Through a REST API the state of the traffic lights can be changed. 
            The drivers follow the instructions of the traffic lights, so if a mistake is made,
            there will be collisions. There is also support for displaying tweets on a HUD.`
          ),
          new Text(
            `This was created for a Cybersecurity challenge. With the help of this program 
            the contestants could instantly see the effect of their work.`
          ),
          new Text(
            `The most interesting aspect of this project was building it in a server-client architecture.
            The decisions of the agents is calculated server-side. The real challenge was broadcasting 
            these decisions in a fault-tolerant way using minimal bandwidth.`
          ),
          new Text(
            `The program is made with Unity using C# as the scripting language. The models and animations
            were also made by me using Blender.`
          ),
        ],
      },
      {
        date: `2018 June`,
        title: `Photo color grader`,
        figure: new Image(color, `a picture of the app`),
        description: new Text(
          `An innovative (at least I thought so) color grader web application.`
        ),
        more: [
          new Text(
            `The most noteworthy feature of this application is the color selector UI. 
            This program is only intended as a proof-of-concept, I wanted to experiment with 
            some ideas and this was the outcome.`
          ),
          new Text(
            `You can select some colors and then apply transformations to the other colors as a 
            function of their distance to the selected color.`
          ),
          new Text(
            `By clicking on a colored circle you can change its settings. 
            New circles can be created by clicking in the large circle (and they can also be moved by drag & drop).`
          ),
          new Anchor('https://color.schmelczer.dev', `color.schmelczer.dev`),
        ],
      },
      {
        date: `2017 autumn`,
        title: `Platform game`,
        figure: new Image(platform, `a picture of the app`),
        description: new Text(
          `A 3D game written in C with the help of SDL 1.2 (I haven't heard of GPU programming at the time).`
        ),
        more: [
          new Text(
            `The maps are randomly generated and fully destroyable. 
            The player is getting chased by flying enemies. Overall, I find it a really enjoyable game.`
          ),
          new Text(
            `I did this as a homework for my Basics of Programming course.`
          ),
        ],
      },
      {
        date: `2016 summer`,
        title: `Photos`,
        figure: new Image(photos, `a picture of the website`),
        description: new Text(
          `A simple web page where you can view my photos.`
        ),
        link: new Anchor(
          `https://photo.schmelczer.dev`,
          `photo.schmelczer.dev`
        ),
      },
      {
        date: `2016 spring`,
        title: `Lights synchronised to music`,
        figure: new Video(
          last(led.images).path,
          ledMP4,
          ledWEBM,
          `controls playsinline preload="none"`
        ),
        description: new Text(
          `A full stack application with a built-in 
          music player which music controls the color of some RGB LED strips.`
        ),
        more: [
          new Text(
            `This was my first non-trivial project which got finished. Obviously, 
            it is rather far from perfect, but I am still proud that I was able to build it on my own.`
          ),
          new Text(
            `The backend logic is written in Python the FFT is provided by NumPy. 
            A quite simple frontend for accessing the music player and changing 
            the settings also got built using vanilla web development technologies.`
          ),
        ],
      },
    ],
  },
  footer: {
    title: `Learn more`,
    curiumVitaes: [
      { name: `Curriculum vitae (en)`, url: cvEnglish },
      { name: `Önéletrajz (hu)`, url: cvHungarian },
    ],
    email: `andras@schmelczer.dev`,
    lastEditText: `Last modified on `,
    lastEdit: new Date(2020, 3, 21), // months are 0 indexed
    gitHub: new Anchor(
      `https://github.com/schmelczerandras/timeline`,
      `Find this on GitHub`
    ),
  },
};